How do you mark a class or method as deprecated/obsolete?
By using the Obsolete attribute
|
1 2 3 4 5 6 7 8 9 10 11 12 |
[Obsolete] public class Person { } [Obsolete("Class is obsolete, use PersonImpl")] public class Person { } //compilation to fail methods calling this code [Obsolete("Class is obsolete, use PersonImpl", true)] public class Person { } [Obsolete("Method is obsolete, use SomeMethod2", true)] public void SomeMethod() { } |
The ?? operator is called the null coalescing operator. It is used for providing a default value for Nullable types or reference types.
Example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
int? age = null; //what ?? implies is possiblyNullValue ?? valueIfNull int myAge = x ?? 100; //if x is not null then assign x else 100 string? person = null; string? localDefault = null; string globalDefault = "abc"; string anybody = person ?? localDefault ?? globalDefault; //chaining ?? //lazy loading/populating private SomeObj _lazyField = null; public SomeObj MyProperty { get { return _lazyField ?? (_lazyField = new SomeObj()); } } |
One of the disadvantage of ?? is it can create code that is not that readable.
e.g a ?? b ?? c ?? d ?? e
In C# you can have property with different scope (property accessors). Properties in C# can be marked as public, private, protected, internal, or protected internal.
Example:
|
1 2 3 4 5 6 7 8 |
public int MyProperty { get; private set; } public string Name { get; protected set;} public int Age { get { return _age; } } // no set but still valid private string Fullname { get; set; } //both are private only class can access it internal string LName { get; set; } //only code in same assembly can access protected internal string FName { get; set; } //only code that inherit and in same assembly virtual string PersonName { get; set; } //use override keyword in derived class static int Count { get; set; } // avaiable to caller at any time |
C# 4.0 allows one to use named and optional parameters.
Example:
|
1 2 3 4 5 6 |
int Calculate(int x = 1, int y = 2) { int someNumber = 0; //some algorithm to calculate return someNumber * y * x + 5 * 0.5; } |
One can call the method in multiple ways
|
1 2 3 4 5 6 7 |
int result = Calculate(1, 2); int result = Calculate(5); //value for x only, y is default to 2 int result = Calculate(); //value for x is 1 and y is 2 int result = Calculate(x: 123, y: 987); //named argument int result = Calculate(y: 345 x: 678); //named argument in reverse int result = Calculate(x: 123, 456); //compiler error not allowed position argument cannot follow name argument int result = Calculate(1, y: 456); //name argument can follow position argument |
Additional note, one cannot provide a gap in arguments.
Example:
|
1 2 3 4 5 6 |
int Calculate(int x, int y = 2, int z) //invalid int Calculate(int x, int y = 1, int z= 5) //valid int result = Calculate(1, , 3); //invalid int result = Calculate(1, 8); //z takes the value of 5 as default |
The using statement in C# is a form of shortcut for try and finally block of code. Things to note is in order to use the using statement the object needs to implement the IDisposable interface, and using does not catch Exception, it just guarantees the call of Dispose.
Example:
|
1 2 3 4 5 6 7 |
try { connection = new SqlConnection(""); } finally { if(connection != null) connection.Close(); } |
Can be replaced with
|
1 2 3 4 |
using(var connection = new SqlConnection("")) { } |
One will not need to call the Close method of sql connection, since the dispose will do that.
In interviews there is always the Singleton question, I personally refuse to answer it on interview. The reason is very simple I don’t code singletons anymore. I use my IoC Container to provide me with a singleton. Sorry if you dont know what an IoC (Inversion of Control Container) is, then you are still in the old ages of coding.
For once and for all here is the hand written code of a singleton in multi-thread environment.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
using System; public sealed class Singleton { private static volatile Singleton instance; private static object syncRoot = new Object(); private Singleton() {} public static Singleton Instance { get { if (instance == null) { lock (syncRoot) { if (instance == null) instance = new Singleton(); } } return instance; } } } |
And here is in an IoC container Unity & StructureMap
|
1 2 3 4 5 6 7 8 9 |
//stucture map var container = new Container(x => { x.ForRequestedType<IEmailService>().CacheBy(InstanceScope.Singleton).TheDefaultIsConcreteType <EmailService>(); }); //unity myContainer.RegisterType<IEmailService, EmailService>(new ContainerControlledLifetimeManager()); |
As you can see one can have a singleton with one line of code in Unity and say 2 lines of code in StructureMap, so I really wonder if one needs to proof that a double check is needed in a multi thread environment for singleton.
End rant……
C# has the as keyword, it is mainly used to cast object of one type to another, and if it fails it should return a null rather than crashing the program or throwing exception.
From MSDN documentation it states:
You can use the as operator to perform certain types of conversions between compatible reference types or nullable types. The as operator is like a cast operation. However, if the conversion isn’t possible, as returns null instead of raising an exception.
|
1 2 3 4 5 6 7 8 |
object obj = GetPersonObj(123); Person p = obj as Person; //using the as keyword if(p != null) p.FullName = p.FirstName + " " + p.LastName; Person p2 = (Person) obj; //this can throw an exception if the object is not a person |
Differences between as and cast ( ) and when to use it:
So C# what is the yield keyword? The yield keyword in C# is basically an iterator, its a form of syntactic sugar added from C# 2.0 to create IEnumerable and IEnumerator objects, thus returning one element at a time.
From MSDN documentation it states.
When you use the yield keyword in a statement, you indicate that the method, operator, or get accessor in which it appears is an iterator. You use an iterator to perform a custom iteration over a collection. The following example shows the two forms of the yield statement.
Personally I have found using yield helpful in XML streaming where I have a very large document but would like to combine the use of XElement with XMLReader, such that the memory is not consumed like XDocument (where it loads the entire document into memory).
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
private IEnumerable<XElement> StreamXElement(string inputUrl) { using (XmlReader reader = XmlReader.Create(inputUrl)) { reader.MoveToContent(); while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && reader.Name == "NodeIWant") { XElement el = XNode.ReadFrom(reader) as XElement; if (el != null) { yield return el; } } } } } //consumption var items = StreamXElement("helloworld.xml"); foreach(var item in items) { //now process the items } |
From the above code it will return an IEnumerable of XElement for us to process.
Some notes on using yield.
The declaration of an iterator must meet the following requirements:
Also one cannot use yield in:
In C# if one wishes to use C# constructor overloading they can use the “this” keyword right after to initialize the object, the only thing to note is one will not be able to do any validation of the data using this method.
Below I have listed 3 ways that one can initialize constructor overload in C#. There is also a base keyword that one can use to call the base class in their constructor initialization code
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
//initialize without checking, use the this keyword public Person(Person p) : this(p.Name, p.Age) { } //provide a method to initialize public Person(string name, int age) { Initialize(name, age); } //validate the input public Person(Person p) { if (p == null) throw new ArgumentNullException("p"); Initialize(p.Name, p.Age); } private void Initialize(string name, int age) { Name = name; Age = age; } //initialize the base class public Person(string name, int age): base(name, age) { } |
C# readonly what is that for? The readonly keyword in C# is used as a modifier. A field can be declared with readonly modifier, and its assignment can only be in the Constructor or when the variable is declared.
An example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public readonly int MinAge = 10; //this is valid public class Person { public readonly int _age; public Person(int age) { _age = age; //this is also valid } public void SetAge(int age) { _age = age; //this is invalid, one cannot set it here would give compile error } public int Age { get { return _age; } //this is also valid no setter just getter } } |
The main thing to understand about readonly modifiers is that they are initialized at runtime, not like const where they initialized at compile time.
One advantage of using readonly is that you do not need to recompile external Dll that may use the value of it, but const would require a replaced of all the dll that are using the value.
The other advantage is to create immutable data structures in your program such they cannot be changed once constructed.
