1685424963
在本 C# 教程中,我们将了解如何使用 C# 生成图像。
要使用 C# 生成图像,您可以使用 System.Drawing 命名空间,它提供用于处理图像的类和方法。
从 NuGet 包管理器下载 NuGet 包 System.Drawing.Common。如果您想了解如何在 Visual Studio 中安装 NuGet 包,请阅读本文 –在 Visual Studio 中安装 NuGet 包
以下是如何生成简单图像的示例:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
在此示例中,我们创建了一个具有所需宽度和高度的新位图对象。然后,我们从图像中获取一个 Graphics 对象,它允许我们在其上绘图。我们使用 DrawRectangle 方法在图像上绘制一个红色矩形。
最后,我们使用 Bitmap 类的 Save 方法将图像保存到文件,指定文件路径和格式(在本例中,我们将其保存为 JPEG 图像)。
保存图像的预览显示在下面的快照中。
请记住在您的项目中添加对 System.Drawing 程序集的引用以使此代码起作用。
文章来源: https: //www.c-sharpcorner.com
1685373720
Neste tutorial C#, aprenderemos como gerar imagens usando C#.
Para gerar uma imagem usando C#, você pode utilizar o namespace System.Drawing, que fornece classes e métodos para trabalhar com imagens.
Baixe o pacote NuGet System.Drawing.Common do gerenciador de pacotes NuGet. Se você gostaria de aprender como instalar pacotes NuGet no Visual Studio, siga este artigo – Instalando pacotes NuGet no Visual Studio
Aqui está um exemplo de como você pode gerar uma imagem simples:
using System;using System.Drawing;class Program{ static void Main() { // Create a blank image with a specified width and height int width = 500; int height = 300; Bitmap image = new Bitmap(width, height); // Create a graphics object from the image Graphics graphics = Graphics.FromImage(image); // Draw a red rectangle on the image Pen pen = new Pen(Color.Red); Rectangle rectangle = new Rectangle(50, 50, 200, 100); graphics.DrawRectangle(pen, rectangle); // Save the image to a file string filePath = "image.jpg"; image.Save(filePath); // Dispose of the graphics object and image graphics.Dispose(); image.Dispose(); Console.WriteLine("Image generated and saved successfully."); }}
Neste exemplo, criamos um novo objeto Bitmap com a largura e altura desejadas. Em seguida, obtemos um objeto Graphics da imagem, que nos permite desenhar sobre ela. Usamos o método DrawRectangle para desenhar um retângulo vermelho na imagem.
Por fim, salvamos a imagem em um arquivo usando o método Save da classe Bitmap, especificando o caminho e o formato do arquivo (neste caso, salvamos como uma imagem JPEG).
Uma visualização da imagem salva é mostrada no instantâneo abaixo.
Lembre-se de adicionar uma referência ao assembly System.Drawing em seu projeto para que esse código funcione.
Fonte do artigo: https://www.c-sharpcorner.com
1685370660
В этом руководстве по C# мы узнаем, как сгенерировать изображение с помощью C#.
Чтобы сгенерировать изображение с помощью C#, вы можете использовать пространство имен System.Drawing, которое предоставляет классы и методы для работы с изображениями.
Загрузите пакет NuGet System.Drawing.Common из диспетчера пакетов NuGet. Если вы хотите узнать, как установить пакеты NuGet в Visual Studio, следуйте этой статье — Установка пакетов NuGet в Visual Studio.
Вот пример того, как вы можете создать простое изображение:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
В этом примере мы создаем новый объект Bitmap с желаемой шириной и высотой. Затем мы получаем объект Graphics из изображения, который позволяет нам рисовать на нем. Мы используем метод DrawRectangle для рисования красного прямоугольника на изображении.
Наконец, мы сохраняем изображение в файл с помощью метода Save класса Bitmap, указав путь к файлу и формат (в данном случае мы сохраняем его как изображение JPEG).
Предварительный просмотр сохраненного изображения показан на снимке ниже.
Не забудьте добавить ссылку на сборку System.Drawing в свой проект, чтобы этот код работал.
Источник статьи: https://www.c-sharpcorner.com
1685360839
Trong hướng dẫn C# này, chúng ta sẽ tìm hiểu về Cách tạo hình ảnh bằng C#.
Để tạo một hình ảnh bằng C#, bạn có thể sử dụng không gian tên System.Drawing, nơi cung cấp các lớp và phương thức để làm việc với hình ảnh.
Tải xuống gói NuGet System.Drawing.Common từ trình quản lý gói NuGet. Nếu bạn muốn tìm hiểu cách cài đặt gói NuGet trong Visual Studio, hãy theo dõi bài viết này - Cài đặt gói NuGet trong Visual Studio
Đây là một ví dụ về cách bạn có thể tạo một hình ảnh đơn giản:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
Trong ví dụ này, chúng tôi tạo một đối tượng Bitmap mới với chiều rộng và chiều cao mong muốn. Sau đó, chúng tôi có được một đối tượng Đồ họa từ hình ảnh, cho phép chúng tôi vẽ trên đó. Chúng ta sử dụng phương thức DrawRectangle để vẽ một hình chữ nhật màu đỏ trên ảnh.
Cuối cùng, chúng tôi lưu hình ảnh vào một tệp bằng phương thức Lưu của lớp Bitmap, chỉ định đường dẫn và định dạng tệp (trong trường hợp này, chúng tôi lưu nó dưới dạng ảnh JPEG).
Bản xem trước của hình ảnh đã lưu được hiển thị trong ảnh chụp nhanh bên dưới.
Hãy nhớ thêm một tham chiếu đến cụm System.Drawing trong dự án của bạn để mã này hoạt động.
Nguồn bài viết: https://www.c-sharpcorner.com
1685346780
In this C# tutorial, we will learn about How to Generate Image using C#.
To generate an image using C#, you can utilize the System.Drawing namespace, which provides classes and methods for working with images.
Download the NuGet package System.Drawing.Common from NuGet package manager. If you would like to learn how to install NuGet packages in Visual Studio follow this article – Installing NuGet Packages In Visual Studio
Here's an example of how you can generate a simple image:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
In this example, we create a new Bitmap object with the desired width and height. Then, we obtain a Graphics object from the image, which allows us to draw on it. We use the DrawRectangle method to draw a red rectangle on the image.
Finally, we save the image to a file using the Save method of the Bitmap class, specifying the file path and format (in this case, we save it as a JPEG image).
A preview of the saved image is shown in the below snapshot.
Remember to add a reference to the System.Drawing assembly in your project for this code to work.
Article source: https://www.c-sharpcorner.com
1685343568
In this tutorial, we will learn about C# string, look at some of the newish things about C# strings ... including raw string literals and raw string interpolation that are new in C# 11with the help of examples.
Much of what we work with in our code are strings. Raw string literals make it easy to build complex, multi-line strings, including JSON, in a simple and flexible way. And with no escaping necessary.
Watch the associated video here:
Find the sample code here.
In this article, we'll start with some of the current techniques we use to handle strings, problems we've faced using those techniques, and new C# 11 features that help with our string handling.
The primary way we've worked with strings in C# is using a quoted string literal. These have been available since the beginning of C#.
string header = "<div class=\"card-header\">Vehicle Detail</div>"
But if we have quotes in our string, the string gets a bit messy. We escape those quotes with a backslash. That way the C# compiler can tell the difference between the outside quotes and any quotes within the string.
Standard quoted string literals are often best for single line strings with no characters that need to be escaped.
For strings that span across multiple lines, we use a verbatim string literal. We define a verbatim string literal with an at sign in front of the first quotation mark. Verbatim means "as is", and is meant to define a multi-line string that displays "as is".
string header = @"
<div class=""card"">
<div class=""card-header"">
Vehicle Detail
</div>
";
But once again, quotation marks are a challenge! Verbatim string literals require that we use double quotation marks to indicate a quotation mark within a string. This doesn't look horrible in this case ... but when creating a string with lots of quotation marks, like defining JSON, it can be quite messy.
Plus, indentation of verbatim string literals can be a problem.
foreach (var vehicle in vehicles)
{
if (goodCredit)
{
if (newVehicle)
{
message = @"
Congratulations on your new vehicle!
We hope you enjoy driving it as much as we enjoyed building it.
";
}
}
}
Above we have a typical bit of code with multiple indentations. And we indent the message nicely within the if block. But then if we display the message, the indentations are included as shown in Figure 1. That may not be the desired result.
Figure 1. Verbatim string literal retains its indentation
To fix it, we'd have to unindent the text to line up with the left margin.
foreach (var vehicle in vehicles)
{
if (goodCredit)
{
if (newVehicle)
{
message = @"
Congratulations on your new vehicle!
We hope you enjoy driving it as much as we enjoyed building it.
";
}
}
}
The result is then better as shown in Figure 2. But the code looks a bit messy. And if some unsuspecting developer comes along to "clean up" the indentation, our result is not as we intended.
Figure 2. Verbatim string literal must be outdented in the code to appear with no indentation
A new feature in C# 11, released in 2022, is a raw string literal. A raw string literal is a new format for string literals. They allow for whitespace, new lines, embedded quotes, other special characters, or whatever!
A raw string literal begins with at least 3 quotes. And ends with a matching set of quotes. Everything on the lines between the opening and closing quotes is the desired string.
string header = """
<div class="card">
<div class="card-header">
Vehicle Detail
</div>
</div>
""";
Notice that there is no need for doubling of the quotes or any escape characters. The string displays exactly as it is. This is a much better choice for multi-line strings over the original verbatim string literal.
Another important feature of raw string literals is that the resulting string aligns to the closing quotes. In the example below, we align the message with the beginning of the closing quote.
foreach (var vehicle in vehicles)
{
if (goodCredit)
{
if (newVehicle)
{
message = """
Congratulations on your new vehicle!
We hope you enjoy driving it as much as we enjoyed building it.
""";
}
}
}
When we display this string, it's aligned appropriately to the left margin as shown in Figure 3.
Figure 3. Raw string literal is indented based on the closing quote
Recall that I said that raw string literals start with at least three quotes. The C# team wanted the feature to have a long life, so they made it configurable. If for some reason you need triple quotes within the string, you could use quad quotes to enclose the raw string literal. Just be sure that the string ends with the same number of quotes.
A single line raw string literal requires that the opening and closing quotes are on the same line. Here is a single line raw string literal. Notice the three quotation marks at the beginning and ending. Then the embedded quotes don't require any special characters.
string text = """He said, "None shall Pass"."""
A multiple line raw string literal requires that the opening quotes are on the line above the raw string and the closing quotes are on their own line below the raw string. Here is a JSON string defined using a raw string literal. Notice that we can use normal quotation marks around the field names and string values. So our JSON looks like JSON.
string vehicleJSON = """
{
"id": 1,
"name": "AT-AT",
"price": 19416.13
}
""";
Since the indenting of the raw string literal is defined by the start of the closing quotes, the text must not be outdented from that closing set of quotes.
The example below has the ending curly brace to the left of the closing quotes. So this code generates a syntax error as shown in Figure 4.
string vehicleJSON = """
{
"id": 1,
"name": "AT-AT",
"price": 19416.13
}
""";
Figure 4. Error message when raw string literal is outdented beyond the closing quotes
Use raw string literals instead of verbatim strings when working with multiple lines or strings with quotes or other special characters that require escape sequences.
With the power, flexibility, and clarity of the raw string literals, you may never use a verbatim string literal again!
We often want to include the value of a variable or expression within a string. That's the purpose of interpolation. String interpolation allows us to insert an expression into a string literal.
string pageTitle = "Vehicle Detail";
string header = $"Header: {pageTitle}";
We identify an interpolated string with a dollar sign in front of the first quote. We add one or more expressions into the string using curly braces. The curly braces act as a placeholder.
At runtime, the expression is evaluated and the appropriate value appears in the string in place of the curly braces and expression. This way we can embed the value of a variable or expression in a string literal.
Here are some examples. We can include a calculation or call a method. Any valid C# expression can be inserted within the curly braces.
string answer = $"Answer: { 20 * 2 + 2 }";
string pageTitle = "Vehicle Detail";
string header = $"Header: {PrepareTitle(pageTitle)}";
As of C# 10, we can define an interpolated string as a constant ... but only if the interpolated expression is a constant, like in this example.
const string pageTitle = "Vehicle Detail";
const string header = $"Header: {pageTitle}";
Since the interpolated expression is a constant in this example, the interpolated string can be defined as a constant. This may not be a very common requirement, but it's nice to know the feature is available if you should need it.
New in C# 11, we can use multiline interpolated expressions. This can make code within the curly braces a bit easier to read.
In this example, we're using the ternary conditional operator. If the page title variable is empty, we set "no title", otherwise we set the page title. Notice that we must enclose the ternary conditional operator in parentheses within the curly braces.
string pageTitle = "";
string header = $"Header: {
(pageTitle == ""
? "No title"
: pageTitle)
}";
Putting too much code inside of an interpolation expression makes that code hard to debug and test. So be careful how much code you write within the interpolated expression. In some cases, it may be better to put the code in a function and call that function from the interpolated expression
We can combine string interpolation with verbatim strings using @$
or $@
. That way we can have multiple lines of text and optionally, multiple lines for our interpolation expression.
string pageTitle = "Vehicle Detail";
string header = @$"
<div class=""card"">
<div class=""card-header"">
{(pageTitle == ""
? "No title"
: pageTitle)}
</div>
</div>
";
But since it is a verbatim string, we again need double quotes for any embedded quotes.
A better option for string interpolation is raw string interpolation, available in C# 11. Here we add the dollar sign in front of our three sets of quotation marks. Then we can define multiple lines of text and multiple lines for our interpolation expression.
string pageTitle = "Vehicle Detail";
string header = $"""
<div class="card">
<div class="card-header">
{(pageTitle == ""
? "No title"
: pageTitle)}
</div>
</div>
""";
Let's look at another example, creating a JSON string. This is the string we want to create. But we want to use interpolation for the price instead of hardcoding it.
{
"id": 1,
"name": "AT-AT",
"price": 19416.13
}
Notice that JSON syntax requires curly braces around the object. But if we want to use an interpolated string, the interpolation needs curly braces. So are we going to need to escape those curly braces? Nope!
The C# team wanted a string interpolation solution that was configurable. So for raw string interpolation, we can optionally use two dollar signs. The two dollar signs means that we need two sets of curly braces for the interpolation. That way the single set of curly braces can be interpreted as part of the string literal.
decimal price = 19416.13M;
string vehicleJSON = $$"""
{
"id": 1,
"name": "AT-AT",
"price": {{price}}
}
""";
Or we could use three dollar signs with three sets of curly braces, and so on. The number of dollar signs indicates the number of pairs of curly braces required for interpolation.
Very cool!
This tutorial walked through options for defining string literals and for string interpolation.
The new raw string literal and raw string interpolation simplify string management, offering a flexible solution for working with strings.
Check out the video here:
Or try out the sample code here.
Source: https://www.freecodecamp.org
#csharp
1685329381
Чтобы сгенерировать изображение с помощью C#, вы можете использовать пространство имен System.Drawing, которое предоставляет классы и методы для работы с изображениями.
Загрузите пакет NuGet System.Drawing.Common из диспетчера пакетов NuGet. Если вы хотите узнать, как установить пакеты NuGet в Visual Studio, следуйте этой статье — Установка пакетов NuGet в Visual Studio.
Вот пример того, как вы можете создать простое изображение:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
В этом примере мы создаем новый объект Bitmap с желаемой шириной и высотой. Затем мы получаем объект Graphics из изображения, который позволяет нам рисовать на нем. Мы используем метод DrawRectangle для рисования красного прямоугольника на изображении.
Наконец, мы сохраняем изображение в файл с помощью метода Save класса Bitmap, указав путь к файлу и формат (в данном случае мы сохраняем его как изображение JPEG).
Предварительный просмотр сохраненного изображения показан на снимке ниже.
Не забудьте добавить ссылку на сборку System.Drawing в свой проект, чтобы этот код работал.
Оригинальный источник статьи: https://www.c-sharpcorner.com/
1685325600
要使用 C# 生成图像,您可以使用 System.Drawing 命名空间,它提供用于处理图像的类和方法。
从 NuGet 包管理器下载 NuGet 包 System.Drawing.Common。如果您想了解如何在 Visual Studio 中安装 NuGet 包,请阅读本文 –在 Visual Studio 中安装 NuGet 包
以下是如何生成简单图像的示例:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
在此示例中,我们创建了一个具有所需宽度和高度的新位图对象。然后,我们从图像中获取一个 Graphics 对象,它允许我们在其上绘图。我们使用 DrawRectangle 方法在图像上绘制一个红色矩形。
最后,我们使用 Bitmap 类的 Save 方法将图像保存到文件,指定文件路径和格式(在本例中,我们将其保存为 JPEG 图像)。
保存图像的预览显示在下面的快照中。
请记住在您的项目中添加对 System.Drawing 程序集的引用,以使此代码生效。
文章原文出处:https: //www.c-sharpcorner.com/
1685325000
To generate an image using C#, you can utilize the System.Drawing namespace, which provides classes and methods for working with images.
Download the NuGet package System.Drawing.Common from NuGet package manager. If you would like to learn how to install NuGet packages in Visual Studio follow this article – Installing NuGet Packages In Visual Studio
Here's an example of how you can generate a simple image:
using System;
using System.Drawing;
class Program
{
static void Main()
{
// Create a blank image with a specified width and height
int width = 500;
int height = 300;
Bitmap image = new Bitmap(width, height);
// Create a graphics object from the image
Graphics graphics = Graphics.FromImage(image);
// Draw a red rectangle on the image
Pen pen = new Pen(Color.Red);
Rectangle rectangle = new Rectangle(50, 50, 200, 100);
graphics.DrawRectangle(pen, rectangle);
// Save the image to a file
string filePath = "image.jpg";
image.Save(filePath);
// Dispose of the graphics object and image
graphics.Dispose();
image.Dispose();
Console.WriteLine("Image generated and saved successfully.");
}
}
In this example, we create a new Bitmap object with the desired width and height. Then, we obtain a Graphics object from the image, which allows us to draw on it. We use the DrawRectangle method to draw a red rectangle on the image.
Finally, we save the image to a file using the Save method of the Bitmap class, specifying the file path and format (in this case, we save it as a JPEG image).
A preview of the saved image is shown in the below snapshot.
Remember to add a reference to the System.Drawing assembly in your project for this code to work.
Original article source at: https://www.c-sharpcorner.com/
1685191271
This repository contains the source code for:
Related repositories include:
Note: Dev Home requires Windows 11 21H2 (build 22000) or later.
Install Dev Home from the Microsoft Store. This allows you to always be on the latest version when we release new builds with automatic upgrades.
This is our preferred method.
For users who are unable to install Dev Home from the Microsoft Store, released builds can be manually downloaded from this repository's Releases page.
winget users can download and install the latest Dev Home release by installing the Microsoft.DevHome
package:
winget install --id Microsoft.DevHome -e
The plan for Dev Home will be posted shortly and will be updated as the project proceeds.
Please take a few minutes to review the overview below before diving into the code:
The Dev Home dashboard displays Windows widgets. These widgets are built using the Windows widget platform, which relies on Adaptive Cards.
The machine configuration tool utilizes the Dev Home GitHub Extension, but isn't required to clone and install apps. The app installation tool is powered by winget.
The machine configuration tool provides a list of popular apps when selecting applications to install. This is currently a hard-coded list of applications that have been popular with developers on Windows. Popularity was determined by high levels of installation and usage. As this is a moment in time, we are not accepting submissions for this list. We're looking to improve the experience with Suggested Apps so the list can be optimized for developers.
Documentation for Dev Home can be found at https://aka.ms/devhomedocs.
We are excited to work alongside you, our amazing community, to build and enhance Dev Home!
BEFORE you start work on a feature/fix, please read & follow our Contributor's Guide to help avoid any wasted or duplicate effort.
The easiest way to communicate with the team is via GitHub issues.
Please file new issues, feature requests, and suggestions but DO search for similar open/closed preexisting issues before creating a new issue.
If you would like to ask a question that you feel doesn't warrant an issue (yet), please reach out to us via Twitter:
winget configure .configurations/configuration.dsc.yaml
from the project root so relative paths resolve correctlyIn Visual Studio, you should be able to build and debug Dev Home by hitting F5. Make sure to select either the "x64" or the "x86" platform and set DevHome as the selected startup project.
We welcome contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.opensource.microsoft.com.
When you submit a pull request, a CLA bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., status check, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.
This project has adopted the Microsoft Open Source Code of Conduct. For more information see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.
This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks or logos is subject to and must follow Microsoft's Trademark & Brand Guidelines. Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.
Author: microsoft
Source Code: https://github.com/microsoft/devhome
License: MIT license
1684395505
Exploring how neural networks learn by programming one from scratch in C#, and then attempting to teach it to recognize various doodles and images.
Chapters
0:00 Introduction
2:39 The decision boundary
3:49 Weights
5:42 Biases
6:45 Hidden layers
7:45 Programming the network
9:57 Activation functions
12:42 Cost
15:07 Gradient descent example
18:22 The cost landscape
19:55 Programming gradient descent
21:10 It's learning! (slowly)
23:21 Calculus example
27:34 The chain rule
29:50 Some partial derivatives
33:14 Backpropagation
39:25 Digit recognition
43:56 Drawing our own digits
47:37 Fashion
48:25 Doodles
52:00 The final challenge
Source code: https://github.com/SebLague/Neural-Network-Experiments
Demo: https://sebastian.itch.io/neural-network-experiment
The data is from:
Digits http://yann.lecun.com/exdb/mnist/
Fashion https://github.com/zalandoresearch/fashion-mnist
Doodles https://github.com/googlecreativelab/quickdraw-dataset
Cifar10 https://www.cs.toronto.edu/~kriz/cifar.html
1683988500
Определите свои свойства в формате ключ-значение в файле Json . Я определил MicroservicesOptions в файле Json.
{
"Logging": {
"LogLevel": {
"Default": "Information"
}
}
"MicroservicesOptions": {
"Application1": "App1",
"Application2": "App2",
"Application3": "App3"
}
}
Создайте класс с такими же свойствами и убедитесь, что имена должны быть точно такими же.
public class MicroservicesOptions
{
public string? Application1 { get; set; }
public string? Application2 { get; set; }
public string? Application3 { get; set; }
}
Внедрить конфигурации в Startup.cs.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.Configure<MicroservicesOptions>(Configuration.GetSection("MicroServices"));
}
Теперь добавьте класс, содержащий свойства, в конструктор желаемого класса, где вам нужно.
public class ValuesController : ControllerBase
{
private readonly MicroservicesOptions _microservicesOptions;
public ValuesController(IOptions<MicroservicesOptions> options)
{
_microservicesOptions = options.Value;
}
}
Оригинальный источник статьи: https://www.c-sharpcorner.com/
1683984780
在 Json 文件中以键值格式定义您的属性。我在 Json 文件中定义了 MicroservicesOptions。
{
"Logging": {
"LogLevel": {
"Default": "Information"
}
}
"MicroservicesOptions": {
"Application1": "App1",
"Application2": "App2",
"Application3": "App3"
}
}
创建一个具有相同属性的类,并确保名称应该完全相同。
public class MicroservicesOptions
{
public string? Application1 { get; set; }
public string? Application2 { get; set; }
public string? Application3 { get; set; }
}
在 Startup.cs 中注入配置。
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.Configure<MicroservicesOptions>(Configuration.GetSection("MicroServices"));
}
现在,在所需类的构造函数中注入一个包含属性的类。
public class ValuesController : ControllerBase
{
private readonly MicroservicesOptions _microservicesOptions;
public ValuesController(IOptions<MicroservicesOptions> options)
{
_microservicesOptions = options.Value;
}
}
文章原文出处: https: //www.c-sharpcorner.com/
1683984660
Define your properties in the key-value format in the Json file. I defined MicroservicesOptions in the Json file.
{
"Logging": {
"LogLevel": {
"Default": "Information"
}
}
"MicroservicesOptions": {
"Application1": "App1",
"Application2": "App2",
"Application3": "App3"
}
}
Make a class with the same properties, and make sure names should be exactly the same.
public class MicroservicesOptions
{
public string? Application1 { get; set; }
public string? Application2 { get; set; }
public string? Application3 { get; set; }
}
Inject configurations in Startup.cs.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
services.Configure<MicroservicesOptions>(Configuration.GetSection("MicroServices"));
}
Now Inject a class containing properties in the constructor of your desired class where you need.
public class ValuesController : ControllerBase
{
private readonly MicroservicesOptions _microservicesOptions;
public ValuesController(IOptions<MicroservicesOptions> options)
{
_microservicesOptions = options.Value;
}
}
Original article source at: https://www.c-sharpcorner.com/
1683978360
A simple C# .NET wrapper library to use with OpenAI's GPT-3 API. More context on my blog. This is an unofficial wrapper library around the OpenAI API. I am not affiliated with OpenAI and this library is not endorsed or supported by them.
var api = new OpenAI_API.OpenAIAPI("YOUR_API_KEY");
var result = await api.Completions.GetCompletion("One Two Three One Two");
Console.WriteLine(result);
// should print something starting with "Three"
Added support for GPT4, streaming conversations with ChatGPT, and supporting IHttpClientFactory
.
Should work with the Azure OpenAI Service. See the Azure section for further details.
Thank you @babrekel, @JasonWei512, @GotMike, @megalon, @stonelv, @ncface, @KeithHenry, @gmilano, @metjuperry, @pandapknaepel, and @Alexei000 for your contributions!
This library is based on .NET Standard 2.0, so it should work across .NET Framework >=4.7.2 and .NET Core >= 3.0. It should work across console apps, winforms, wpf, asp.net, etc (although I have not yet tested with asp.net). It should work across Windows, Linux, and Mac, although I have only tested on Windows so far.
Install package OpenAI
from Nuget. Here's how via commandline:
Install-Package OpenAI
There are 3 ways to provide your API keys, in order of precedence:
APIAuthentication(string key)
constructor.openai
and containing the line:OPENAI_API_KEY=sk-aaaabbbbbccccddddd
You use the APIAuthentication
when you initialize the API as shown:
// for example
OpenAIAPI api = new OpenAIAPI("YOUR_API_KEY"); // shorthand
// or
OpenAIAPI api = new OpenAIAPI(new APIAuthentication("YOUR_API_KEY")); // create object manually
// or
OpenAIAPI api = new OpenAIAPI(APIAuthentication LoadFromEnv()); // use env vars
// or
OpenAIAPI api = new OpenAIAPI(APIAuthentication LoadFromPath()); // use config file (can optionally specify where to look)
// or
OpenAIAPI api = new OpenAIAPI(); // uses default, env, or config file
You may optionally include an openAIOrganization (OPENAI_ORGANIZATION in env or config file) specifying which organization is used for an API request. Usage from these API requests will count against the specified organization's subscription quota. Organization IDs can be found on your Organization settings page.
// for example
OpenAIAPI api = new OpenAIAPI(new APIAuthentication("YOUR_API_KEY","org-yourOrgHere"));
The Chat API is accessed via OpenAIAPI.Chat
. There are two ways to use the Chat Endpoint, either via simplified conversations or with the full Request/Response methods.
The Conversation Class allows you to easily interact with ChatGPT by adding messages to a chat and asking ChatGPT to reply.
var chat = api.Chat.CreateConversation();
/// give instruction as System
chat.AppendSystemMessage("You are a teacher who helps children understand if things are animals or not. If the user tells you an animal, you say \"yes\". If the user tells you something that is not an animal, you say \"no\". You only ever respond with \"yes\" or \"no\". You do not say anything else.");
// give a few examples as user and assistant
chat.AppendUserInput("Is this an animal? Cat");
chat.AppendExampleChatbotOutput("Yes");
chat.AppendUserInput("Is this an animal? House");
chat.AppendExampleChatbotOutput("No");
// now let's ask it a question'
chat.AppendUserInput("Is this an animal? Dog");
// and get the response
string response = await chat.GetResponseFromChatbotAsync();
Console.WriteLine(response); // "Yes"
// and continue the conversation by asking another
chat.AppendUserInput("Is this an animal? Chair");
// and get another response
response = await chat.GetResponseFromChatbotAsync();
Console.WriteLine(response); // "No"
// the entire chat history is available in chat.Messages
foreach (ChatMessage msg in chat.Messages)
{
Console.WriteLine($"{msg.Role}: {msg.Content}");
}
Streaming allows you to get results are they are generated, which can help your application feel more responsive.
Using the new C# 8.0 async iterators:
var chat = api.Chat.CreateConversation();
chat.AppendUserInput("How to make a hamburger?");
await foreach (var res in chat.StreamResponseEnumerableFromChatbotAsync())
{
Console.Write(res);
}
Or if using classic .NET Framework or C# <8.0:
var chat = api.Chat.CreateConversation();
chat.AppendUserInput("How to make a hamburger?");
await chat.StreamResponseFromChatbotAsync(res =>
{
Console.Write(res);
});
You can access full control of the Chat API by using the OpenAIAPI.Chat.CreateChatCompletionAsync()
and related methods.
async Task<ChatResult> CreateChatCompletionAsync(ChatRequest request);
// for example
var result = await api.Chat.CreateChatCompletionAsync(new ChatRequest()
{
Model = Model.ChatGPTTurbo,
Temperature = 0.1,
MaxTokens = 50,
Messages = new ChatMessage[] {
new ChatMessage(ChatMessageRole.User, "Hello!")
}
})
// or
var result = api.Chat.CreateChatCompletionAsync("Hello!");
var reply = results.Choices[0].Message;
Console.WriteLine($"{reply.Role}: {reply.Content.Trim()}");
// or
Console.WriteLine(results);
It returns a ChatResult
which is mostly metadata, so use its .ToString()
method to get the text if all you want is assistant's reply text.
There's also an async streaming API which works similarly to the Completions endpoint streaming results.
The Completion API is accessed via OpenAIAPI.Completions
:
async Task<CompletionResult> CreateCompletionAsync(CompletionRequest request);
// for example
var result = await api.Completions.CreateCompletionAsync(new CompletionRequest("One Two Three One Two", model: Model.CurieText, temperature: 0.1));
// or
var result = await api.Completions.CreateCompletionAsync("One Two Three One Two", temperature: 0.1);
// or other convenience overloads
You can create your CompletionRequest
ahead of time or use one of the helper overloads for convenience. It returns a CompletionResult
which is mostly metadata, so use its .ToString()
method to get the text if all you want is the completion.
Streaming allows you to get results are they are generated, which can help your application feel more responsive, especially on slow models like Davinci.
Using the new C# 8.0 async iterators:
IAsyncEnumerable<CompletionResult> StreamCompletionEnumerableAsync(CompletionRequest request);
// for example
await foreach (var token in api.Completions.StreamCompletionEnumerableAsync(new CompletionRequest("My name is Roger and I am a principal software engineer at Salesforce. This is my resume:", Model.DavinciText, 200, 0.5, presencePenalty: 0.1, frequencyPenalty: 0.1)))
{
Console.Write(token);
}
Or if using classic .NET framework or C# <8.0:
async Task StreamCompletionAsync(CompletionRequest request, Action<CompletionResult> resultHandler);
// for example
await api.Completions.StreamCompletionAsync(
new CompletionRequest("My name is Roger and I am a principal software engineer at Salesforce. This is my resume:", Model.DavinciText, 200, 0.5, presencePenalty: 0.1, frequencyPenalty: 0.1),
res => ResumeTextbox.Text += res.ToString());
The Embedding API is accessed via OpenAIAPI.Embeddings
:
async Task<EmbeddingResult> CreateEmbeddingAsync(EmbeddingRequest request);
// for example
var result = await api.Embeddings.CreateEmbeddingAsync(new EmbeddingRequest("A test text for embedding", model: Model.AdaTextEmbedding));
// or
var result = await api.Embeddings.CreateEmbeddingAsync("A test text for embedding");
The embedding result contains a lot of metadata, the actual vector of floats is in result.Data[].Embedding.
For simplicity, you can directly ask for the vector of floats and disgard the extra metadata with api.Embeddings.GetEmbeddingsAsync("test text here")
The Moderation API is accessed via OpenAIAPI.Moderation
:
async Task<ModerationResult> CreateEmbeddingAsync(ModerationRequest request);
// for example
var result = await api.Moderation.CallModerationAsync(new ModerationRequest("A test text for moderating", Model.TextModerationLatest));
// or
var result = await api.Moderation.CallModerationAsync("A test text for moderating");
Console.WriteLine(result.results[0].MainContentFlag);
The results are in .results[0]
and have nice helper methods like FlaggedCategories
and MainContentFlag
.
The Files API endpoint is accessed via OpenAIAPI.Files
:
// uploading
async Task<File> UploadFileAsync(string filePath, string purpose = "fine-tune");
// for example
var response = await api.Files.UploadFileAsync("fine-tuning-data.jsonl");
Console.Write(response.Id); //the id of the uploaded file
// listing
async Task<List<File>> GetFilesAsync();
// for example
var response = await api.Files.GetFilesAsync();
foreach (var file in response)
{
Console.WriteLine(file.Name);
}
There are also methods to get file contents, delete a file, etc.
The fine-tuning endpoint itself has not yet been implemented, but will be added soon.
The DALL-E Image Generation API is accessed via OpenAIAPI.ImageGenerations
:
async Task<ImageResult> CreateImageAsync(ImageGenerationRequest request);
// for example
var result = await api.ImageGenerations.CreateImageAsync(new ImageGenerationRequest("A drawing of a computer writing a test", 1, ImageSize._512));
// or
var result = await api.ImageGenerations.CreateImageAsync("A drawing of a computer writing a test");
Console.WriteLine(result.Data[0].Url);
The image result contains a URL for an online image or a base64-encoded image, depending on the ImageGenerationRequest.ResponseFormat (url is the default).
Image edits and variations are not yet implemented.
For using the Azure OpenAI Service, you need to specify the name of your Azure OpenAI resource as well as your model deployment id.
I do not have access to the Microsoft Azure OpenAI service, so I am unable to test this functionality. If you have access and can test, please submit an issue describing your results. A PR with integration tests would also be greatly appreciated. Specifically, it is unclear to me that specifying models works the same way with Azure.
Refer the Azure OpenAI documentation and detailed screenshots in #64 for further information.
Configuration should look something like this for the Azure service:
OpenAIAPI api = OpenAIAPI.ForAzure("YourResourceName", "deploymentId", "api-key");
api.ApiVersion = "2023-03-15-preview"; // needed to access chat endpoint on Azure
You may then use the api
object like normal. You may also specify the APIAuthentication
is any of the other ways listed in the Authentication section above. Currently this library only supports the api-key flow, not the AD-Flow.
As of April 2, 2023, you need to manually select api version 2023-03-15-preview
as shown above to access the chat endpoint on Azure. Once this is out of preview I will update the default.
While this library does not fully support dependancy injection at this time, you may specify an IHttpClientFactory
to be used for HTTP requests, which allows for tweaking http request properties, connection pooling, and mocking. Details in #103.
OpenAIAPI api = new OpenAIAPI();
api.HttpClientFactory = myIHttpClientFactoryObject;
Every single class, method, and property has extensive XML documentation, so it should show up automatically in IntelliSense. That combined with the official OpenAI documentation should be enough to get started. Feel free to open an issue here if you have any questions. Better documentation may come later.
Author: OkGoDoIt
Source Code: https://github.com/OkGoDoIt/OpenAI-API-dotnet
License: View license