Diese Präsentation wurde erfolgreich gemeldet.
Wir verwenden Ihre LinkedIn Profilangaben und Informationen zu Ihren Aktivitäten, um Anzeigen zu personalisieren und Ihnen relevantere Inhalte anzuzeigen. Sie können Ihre Anzeigeneinstellungen jederzeit ändern.
1 
(6) Introduction of C# Basics – Advanced Features 
– Part I 
Nico Ludwig (@ersatzteilchen)
2 
TOC 
● (6) Introduction of C# – Advanced Features – Part I 
– Namespaces 
– Assemblies 
– Error Handling with Exception...
3 
Namespaces 
● .Net namespaces allow to organize types generally. 
– .Net's core types are defined in the namespace Syst...
4 
Namespaces in C# Code 
using System; // A namespace directive. 
using SIO = System.IO; // Namespace System.IO aliased a...
5 
Assemblies 
● Assemblies are the smallest units of security and deployment. 
– They allow modular development and separ...
6 
Referencing 3rd Party Libraries into an Application 
● We can reference libraries by referencing assemblies into the ap...
7 
Classical Handling of Run Time Errors 
● Syntax errors vs. logic errors vs. run time errors. 
● Classically, after an o...
8 
Classical Handling of Run Time Errors in C Code 
char* chars = (char*)malloc(10); 
// Was memory allocation successful?...
9 
Exception Handling in C# Code 
try // Run time error prone code goes here: 
{ 
string theText = File.ReadAllText("Text....
10 
Run Time Error Handling with Exceptions 
● Exception code separates effective code from error handling code syntactica...
11 
Enums 
● Typisized set of integral constants. 
– Useful for discrete integral constants or flags. 
– Known from C/C++,...
12 
public void Foo() 
{ 
// Reference type System.String: 
String aString = "ABC"; 
// Assignment copies the reference, b...
13 
Value Types – Part I 
● Reference types: All the types we have created by now are reference types. 
– References, i.e....
14 
Value Types – Part II 
● Local values differ from references: 
– Values are created on the stack. They are default ini...
15 
public void Bar() 
{ 
// Value type System.Drawing.Point: 
Point aPoint = new Point(1, 2); 
// Assignment copies the v...
16 
When to use Value Types 
● Make the creation of user defined value types an exceptional case! 
● When to use value typ...
17 
Thank you!
Nächste SlideShare
Wird geladen in …5
×

(6) c sharp introduction_advanced_features_part_i

- Namespaces
- Assemblies
- Error Handling with Exceptions
- Enums
- Value Types and Reference Types

  • Als Erste(r) kommentieren

  • Gehören Sie zu den Ersten, denen das gefällt!

(6) c sharp introduction_advanced_features_part_i

  1. 1. 1 (6) Introduction of C# Basics – Advanced Features – Part I Nico Ludwig (@ersatzteilchen)
  2. 2. 2 TOC ● (6) Introduction of C# – Advanced Features – Part I – Namespaces – Assemblies – Error Handling with Exceptions – Enums – Value Types and Reference Types
  3. 3. 3 Namespaces ● .Net namespaces allow to organize types generally. – .Net's core types are defined in the namespace System. ● A namespace reduces the risk of clashing type names. – Type names can be qualified with the namespace name. – E.g. the types in libraries are held in own library namespaces. ● Syntactical specialties: – Nesting: a namespace can contain other nested namespaces (like boxes in boxes). – A namespace directive imports all types of a namespace with the using keyword. – Only complete namespaces can be imported. – Complex namespace names (e.g. nested ones) can be aliased. – The . and :: punctuators can be used to access aliased namespaces. – The global:: keyword allows to re-refer the global namespace (used rarely). ● What does that mean: types can "clash"? ● The CLI doesn't know the concept of namespaces, instead it knows the concept of "DottedNames" and all type names must be fully qualified in the IL code, though. ● C# also allows defining nested types as members, i.e. type definitions in enclosing type definitions (e.g. classes in classes). The syntax to access nested types is similar to the syntax accessing nested namespaces (only the dot punctuator is allowed, e.g.: OuterType.InnerType). ● The global:: keyword is often used, when code is automatically generated by tools. ● When is such code getting generated? ● Attention: namespaces are open! - So we can spread our namespace among several files, which is ok so far. But we should not “extend” namespaces of the .Net framework (like System) or namespaces from 3rd party vendors! The types we develop at Avid should be held in a namespace, being named following the coding conventions.
  4. 4. 4 Namespaces in C# Code using System; // A namespace directive. using SIO = System.IO; // Namespace System.IO aliased as SIO. namespace Namespaces { // A namespace definition. namespace OtherNamespace { // A nested namespace definition. public class Program{} } public class Program { public static void Main(string[] args) { System.IO.File file = null; // A fully qualified type. SIO.File file2 = null; // A via-alias qualified type. SIO::File file3 = null; // A via-alias qualified type. } } } ● Here namespaces are used to make two equally names not clash. - This downright a bad design. The idea of namespaces is not to resolve name conflicts, but to organize type to make them better searchable.
  5. 5. 5 Assemblies ● Assemblies are the smallest units of security and deployment. – They allow modular development and separation of common code. ● Assemblies are self contained. ● Assemblies are represented by standalone executables or dlls. ● Types within assemblies can be encapsulated with the access modifier internal. ● The types defined in a namespace can be spread among assemblies. – Often a certain assembly defines its types in its own namespace as a library. – But this is not obligatory. ● Types that are declared as internal are generally not accessible from other assemblies.
  6. 6. 6 Referencing 3rd Party Libraries into an Application ● We can reference libraries by referencing assemblies into the application: ● After the reference was added, a contained API can be accessed via its namespace. // Use the namespace as qualifier: System.Windows.Forms.Form f = new System.Windows.Forms.Form(); // Open the namespace with a namespace directive: using System.Windows.Forms; ● This example shows how namespaces and assemblies relate.
  7. 7. 7 Classical Handling of Run Time Errors ● Syntax errors vs. logic errors vs. run time errors. ● Classically, after an operation was done, the result should be checked. – E.g. the content of a register is checked (in an assembly language). – E.g. the returned value of a function is checked. ● If the result indicates error, the code has to branch... ● If an error condition was ignored (not checked), unexpected things may happen. – This can lead to undefined behavior of an application. ● Dilemma: Effective code and error handling code is mixed. ● Syntax errors are errors that are found by the compiler (e.g. typos in symbol names or keywords). ● Logic errors are errors in the code that are not found by the compiler but result in wrong behavior of our code. ● Run time errors are a kind of logic errors that result in an irrecoverable state of the program.
  8. 8. 8 Classical Handling of Run Time Errors in C Code char* chars = (char*)malloc(10); // Was memory allocation successful? if (chars) { FillBuffer(chars); printf("Buffer content: %s", chars); free(chars); } else { // Oh, memory allocation was not successful! printf("Ouch! Could not create char array!"); }
  9. 9. 9 Exception Handling in C# Code try // Run time error prone code goes here: { string theText = File.ReadAllText("Text.txt"); // Might throw an Exception. string a2ndText = File.ReadAllText("Text.txt"); // Might throw an Exception. } catch(FileNotFoundException exc) // We can handle FileNotFoundExceptions: { Console.WriteLine("FileNotFoundException thrown: "+exc.Message); } catch(Exception exc) // And we can handle other .Net Exceptions: { Console.WriteLine("Exception thrown: "+exc.Message); } finally // But under all circumstances this code will be executed: { Console.WriteLine("The last word is mine!"); } ● However, if an Exception is thrown in the first line, the second line will not be reached at all. ● Exceptions in comparison to return statements: Sometimes, if a very significant thing happens, we want to pass control through multiple functions. - Then a return statement is not enough and Exceptions come into play. ● Error situations in ctors and many operators must be done with exceptions, because we don't have high flexibility on return types, however. ● In VB the possibilities with Catch clauses are more elaborate: ● An optional Exit Try can exit from a Try or Catch block, resuming the execution after the End Try block. ● An optional When clause, being specified after a Catch clause, can contribute additional criteria that must meet together with the Catch's exception type, so that the handler will execute.
  10. 10. 10 Run Time Error Handling with Exceptions ● Exception code separates effective code from error handling code syntactically. – This is done by try and catch/finally blocks. ● Exception objects represent error conditions, they can't be ignored, but just... – … "happen" (are being thrown) somewhere in the try block. And then: ● Alternative 1: Caught and handled in the matching catch block. ● Alternative 2: Ignored! - The method will be exited immediately and the exception will be forwarded. – The stack of the exception will be unwound. ● Alternative 3: Suppressed, results in a postcondition as nothing has happened. ● Exceptions are types that are designed in an inheritance hierarchy. ● catch handlers work like "filters" for exceptions. – The dynamic type of an Exception is matched against handler signatures. – Hierarchical Exceptions and dynamic type checking works very intuitively. ● The term Exception has nothing to do with frequency they "happen". ● Exceptions may be thrown everywhere and every times, e.g. StackOverflowException, OutOfMemoryException or ExecutionEngineException.
  11. 11. 11 Enums ● Typisized set of integral constants. – Useful for discrete integral constants or flags. – Known from C/C++, Pascal and Java. ● Used to express options and flags in various .Net APIs. – System.Windows.Forms.DialogResult – System.IO.FileAttributes – System.Text.RegularExpressions.RegexOptions ● An enum type implicitly inherits from the value type System.Enum. – User defined enums can not define methods. – But all enums provide some operator overloads, though. ● What does that mean "typisized set of integral constants"? ● Constants that express instances of the same concept. E.g. the four directions would be represented with the constants North, East, South and West. Because we'll only use these constants' names in the code, we'll be never interested in their "real" integral values. A suitable name of that "integral set" type would be "Direction". ● What are flags? ● The idea is that a single value can represent a combination of values (so called flags).
  12. 12. 12 public void Foo() { // Reference type System.String: String aString = "ABC"; // Assignment copies the reference, but both // references point to the same object in heap. String sndString = aString; } Memory Situation of Reference Types Heap Stack aString = 0x23452113 Stack sndString = 0x23452113 "ABC" ● A variable of a reference type represents a pointer to an object on the heap. The variable is only a shortcut to the "real" object in the heap.
  13. 13. 13 Value Types – Part I ● Reference types: All the types we have created by now are reference types. – References, i.e. variables of reference type, hold only a shortcut to a location in heap. – When the references are exchanged between methods, the objects won't be copied. ● This is call by reference: We're only passing around shortcuts to the same object. – References can also refer to nothing, then they have the value null. ● But sometimes "lightweight types" are sufficient to represent a concept. – Such as int, Point, KeyValuePair<K, V>, enum etc. ● These lightweight types are called value types in .Net, variables are called values. ● C# allows specifying user defined value types, so called structs. ● Value types are further divided into simple types, enum types, struct types, and nullable types. ● Reference types are further divided into class types, interface types, array types, and delegate types.
  14. 14. 14 Value Types – Part II ● Local values differ from references: – Values are created on the stack. They are default initialized! – Reference types provide overhead, which value types do not need. – They have different equality semantics by default (identity versus content equality). ● Value types in C#: – Syntactically defined like classes, but with the keyword struct. – As locals, they're created on the stack, even if the keyword new is used! – Can't act as subtype or base type (structs are always sealed). – Derive from type System.ValueType implicitly and can implement interfaces. – Have a sequential memory layout (default) and act as backdoor to Win32 PODs. ● In C++ we can decide where (stack or heap) an object is created during creation. – In C# we have to specify the "where" on the type definition (class or struct)! ● According local value objects: What is the "stack"? ● Reference types' overhead: they do carry a vtable cataloging the virtual methods' addresses and a sync block index needed for synchronization in multithreaded scenarios. ● Equality semantics: We can consider Reference types as "entity types" that have "identity continuation", whereas for value types we're not interested whether the value "green" is the same "green" as tomorrow. ● Concerning value types can't act as a base type, there is one exception: actually the type System.Enum derives from System.ValueType and System.Enum is the base type of all enum types. ● According value types in C#: What is a memory layout? ● It defines how the fields of a type are laid out in memory for an instance: sequence, alignment and padding. By default, structs are laid out sequentially (compatible with Win32 types) and classes are laid out automatically (the layout is automatically optimized for the type by the runtime). ● What is a "POD"? Plain Old Datatype
  15. 15. 15 public void Bar() { // Value type System.Drawing.Point: Point aPoint = new Point(1, 2); // Assignment copies the value. Both objects // have independent copies of the value // {1, 2}. Modification modifies just one copy! Point sndPoint = aPoint; sndPoint.Y = 4; } Memory Situation of Value Types Heap (is uninvolved) Stack aPoint = {X = 1, Y = 2} Stack aPoint = {X = 1, Y = 2} sndPoint = {X = 1, Y = 4} ● A variable of a value type directly represents all the values of the fields of the object on the stack.
  16. 16. 16 When to use Value Types ● Make the creation of user defined value types an exceptional case! ● When to use value types: – Use them for small types. .Net enums are a good example for value types. – Use them to interact with legacy (Win32), i.e. exploit the sequential memory layout. – Exploit default content equality semantics (i.e. "value type" equality semantics). ● Contra value types: – Don't use them if objects are often passed/returned to/from methods (call by value). – Conversion from and to reference types should be avoided (boxing/unboxing). – Value types can not be used in inheritance hierarchies. – Value types can not be thread locked. ● C#'s structs are a completely different concept compared to C++' structs. ● In C++, classes vs. structs are means to control accessibility of contained and inherited members. In C#, classes vs. structs are used to define different sorts of types, reference types and value types.
  17. 17. 17 Thank you!

×