C# recipes



The following code example defines a method that takes a string parameter.

Creates a public void method declaration


The code defines a public property named Name. When the code is executed, the Name property gets access to the value assigned to it when the code is initialized. The Name property can also be accessed directly with the address of the property, which is automatically generated for you when you create a class.

Creates an init property


The Name property gets and sets the name of the object.

Creates a property read only


The _name field is private and readonly, which means that it cannot be changed. The public keyword indicates that this field is visible to the outside world.

Creates an immutable property



The Name property gets and sets the value of the name property of the object.

Creates a property


The code above will display a message box with the text "Hello" on the form.

Creates a Windows Message Box

Creates a Namespace



In the above code, the async keyword means that the code will run asynchronously. The code inside the brackets, called the await keyword, tells the compiler that the code inside will wait for the result of the MyMethodAsync() method. If the code execution reaches the } and the MyMethodAsync() method returns a result, the code will continue and the result will be assigned to the parameter. If the MyMethodAsync() method returns an error, the execution of the code will stop and an error will be reported.

Creates an Async Method structure



This code defines a method named MyMethod that takes a single string parameter.

Creates a Method structure



This code is a main function that is defined in a class. This function will be called when the program is started.

Creates a Console Main structure



This code uses the .Where method of the LINQ to SQL query engine to filter the collection of items based on a field that contains a text value.

Creates a LINQ Where sentence



The lock() function will block execution of the current thread until the thread owning the lock variable has unlocked the lock.

Creates a lock statement



The Distinct() method would return a collection of objects that have been selected, but not duplicated, from the collection.

Creates a LINQ Distinct sentence



The interface IMyInterface has one method.

Creates an interface


The code defines two variables, value and result. The value variable is set to true, and the result variable is set to either true or false.

Creates a conditional operator



The ImmutableObject class has a private readonly string _name field. A public Name property is defined which takes a function that will be called when the object is set. This function will set the _name field to the object's current name.

Creates an immutable object



The code if (true) executes the block of code between the curly braces if the condition is true. If the condition is not true, the code between the curly braces else executes.

Creates an if else statement


The following code creates a new Guid object. A Guid object holds a unique identifier for a particular object.

Creates a new instance of the Guid structure



This code fragment iterates over the length of the array and prints the values of each element.

Creates a for loop



The code within the foreach block will iterate through the collection and print each item.

Creates a foreach statement



The MyException class inherits from System.Exception. Its constructor takes two arguments: a message string and an inner exception. The public virtual functions defined on the MyException class allow any object to create a instance of the MyException class, and pass in the message string and the inner exception. Finally, the public virtual function allows an object to serialize the MyException class with the given information and context.

Creates an exception class



The code snippet declares an enum type with the name "MyEnumType".

Creates an enum type



The code block will run until it encounters a break statement or until it encounters a statement that terminates the loop.

Creates a do while loop


When this code executes, it will print "Text".

Creates a call to WriteLine


This code executes the ReadLine method of the Console class and returns whatever is entered into the Console window

Creates a call to ReadLine


When the code is run, the ReadKey() method is called on the console object, which causes the keyboard to be displayed so that the user can enter a key. This key is then processed by the code and used to determine what action to take.

Creates a call to ReadKey


Constants are defined in code as constants. A constant value is a specific, unchanging value that is used in code.

The CONSTANT_NAME constant value is "value".

Creates a constant



This code is from a class that implements IDisposable. When the class is disposed of, the GC will suppress the finalizer for this class.

Creates a disposable class



The class keyword indicates that the following is a class. Inside of the class, there is a code block that contains the class declaration. This code block tells the interpreter that this class exists and provides some basic information about the class.

Creates a class

Creates an abstract class declaration




The code starts the console application, and then asks the user to press any key to exit. If the user presses a key, the code will exit and the console application will be closed.

General output to console


The above code clears the console screen.

Creates a call to Clear



This code creates a new program object and calls the Main() method.

Creates a HelloWorld sample

List of snippets for Rust to facilitate coding

Rust snippets



The code produces an error because the function name() doesn't exist.

test_fn



The test flag indicates that this code is for testing purposes only and should not be used in production.

test_mod



The first line creates a mod environment, which is a shell command that is run in the background. The second line invokes the pub mod command, which publishes the current working directory to the public directory.

filesystem;

This code tells the Rust compiler to use the crate file system.



The code defines an anonymous function that prints "Ok" and returns a future that will resolve with the value 1.

async_fn



This function takes no arguments and returns an integer.

method



This code creates an impl for the trait_name type. This impl creates a new type that is a combination of the type given in the trait_name and the current type.

impl_trait



In the code, the impl type function creates a new type. The function takes no arguments.

const/method



The code declares a new type that implements the ${1|Clone,Copy,Debug,Deref,Display,Drop,Hashable,Send,Sync|} traits.

impl_known_trait



The code shown defines an enum type named name, which can have any value that is possible for an int.

enum



The following code defines a trait named name. This trait defines a single method named hello, which takes an instance of T as a parameter and prints "Hello, world!" to the console.

trait

 {

private:

T name;

};



name<int> name1;

name<string> name2;

astruct



The loop will iterate through the optional value until it is nil.

while?

struct



The code prints out each value in the iterator, in order.



The while loop will keep executing until the test expression evaluates to false.

while



The code looks for a match within the variable expr. The matched pattern will be stored in the variable matched.

Name	Language	Author	Uses
Creates a public void method declaration	C#	l lucycodes42	2
Creates an init property	C#	l lucycodes42	2
Creates a property read only	C#	l lucycodes42	0
Creates an immutable property	C#	l lucycodes42	1
Creates a property	C#	l lucycodes42	0
Creates a Windows Message Box	C#	l lucycodes42	0
Creates a Namespace	C#	l lucycodes42	1
Creates an Async Method structure	C#	l lucycodes42	5
Creates a Method structure	C#	l lucycodes42	2
Creates a Console Main structure	C#	l lucycodes42	1
Creates a LINQ Where sentence	C#	l lucycodes42	2
Creates a lock statement	C#	l lucycodes42	0
Creates a LINQ Distinct sentence	C#	l lucycodes42	1
Creates an interface	C#	l lucycodes42	2
Creates a conditional operator	C#	l lucycodes42	0
Creates an immutable object	C#	l lucycodes42	0
Creates an if else statement	C#	l lucycodes42	1
Creates a new instance of the Guid structure	C#	l lucycodes42	0
Creates a for loop	C#	l lucycodes42	49
Creates a foreach statement	C#	l lucycodes42	9
Creates an exception class	C#	l lucycodes42	16
Creates an enum type	C#	l lucycodes42	1
Creates a do while loop	C#	l lucycodes42	4
Creates a call to WriteLine	C#	l lucycodes42	1
Creates a call to ReadLine	C#	l lucycodes42	1
Creates a call to ReadKey	C#	l lucycodes42	2
Creates a constant	C#	l lucycodes42	1
Creates a disposable class	C#	l lucycodes42	13
Creates a class	C#	l lucycodes42	34
Creates an abstract class declaration	C#	l lucycodes42	5
General output to console	C#	l lucycodes42	1
Creates a call to Clear	C#	l lucycodes42	0
Creates a HelloWorld sample	C#	l lucycodes42	0
test_fn	Rust	l lucycodes42	1
test_mod	Rust	l lucycodes42	4
mod	Rust	l lucycodes42	2
use	Rust	l lucycodes42	3
async_fn	Rust	l lucycodes42	3
method	Rust	l lucycodes42	0
impl_trait	Rust	l lucycodes42	0
const/method	Rust	l lucycodes42	0
impl_known_trait	Rust	l lucycodes42	0
enum	Rust	l lucycodes42	0
trait	Rust	l lucycodes42	1
astruct	Rust	l lucycodes42	0
while?	Rust	l lucycodes42	3
struct	Rust	l lucycodes42	3
for	Rust	l lucycodes42	0
while	Rust	l lucycodes42	0
match	Rust	l lucycodes42	1

Codiga Snippets, page 41