If this is C# 4.0, you can use named *arguments* feature:

    foo(x: 5, optionalZ: 8); 

See [this blog][1] for more information.

  [1]: http://geekswithblogs.net/michelotti/archive/2009/01/22/c-4.0-named-parameters-for-better-code-quality.aspx

In C# 4.0 you can name the arguments occurring after skipped defaults like this:

    int returnVal = foo(5, optionalZ: 8);

This is called as [named arguments](http://weblogs.asp.net/podwysocki/archive/2008/10/28/named-and-optional-arguments-in-c-4-0.aspx). Several others languages provide this feature, and it&#39;s common form them to use the syntax `foo(5, optionalZ=8)` instead, which is useful to know when reading code in other languages.

Another dynamic way to supply parameters of your choise is to implement your method(s) in a class and supply named parameters to the class constructor. Why not even add calls to methods on same line of code as mentioned here : https://stackoverflow.com/questions/12056639/how-to-define-named-parameters-c-sharp

&gt;var p = new PersonInfo { Name = &quot;Peter&quot;, Age = 15 }.BuildPerson();

This is a late answer, but for the people who get into this.
One could also use Overloads,that uses the same name as the method/function, but with a different set of parameters.

ea

    int SummAll (int a=0, int b=1, int c=2)
    {return a+b+c;}

    int SumAll (int a=0;int c=10) //skipping B 
    {return a+c; }

This pattern equals how with intellicense we can browse through variations of functions.

The .gitignore file is very useful in ignoring some of the files that we don&#39;t want to control. Unfortunately, it cannot be used when the file is already under version control. For example, my .gitignore (which is already added to git) file might be different than what my coworker wants it to be (e.g. I want to ignore Vim files). Whenever I make changes to this file, git shows it as a modified file. So my questions:

1. Is there any way to ignore changes for a certain file, which is already controlled by Git?!
2. Is there any way to commit these changes, but keep it for myself only? Obviously, I don&#39;t want to use a branch, because I am working on a certain branch.


Git: Ignoring Version-Controlled Files

I&#39;v written a plugin where it comes to parsing a XML tag. The content inside the tag is indented and when i copy the parsed string into the file it&#39;s gettting like:


        Example line
            This is part of the parsed line
            Thats goes one
        End of line


What I want is to remove all spaces in front of these lines, the final text should be 

    Example line
    This is part of the parsed line
    Thats goes one
    End of line

I&#39;ve tried to use `=` but it doesn&#39;t work the way I want. How can I do that with minimal key strokes ? 

Remove all arbitary spaces before a line in Vim

Example: 

    public int foo(int x, int optionalY = 1, int optionalZ = 2) { ... }

I&#39;d like to call it like this:

    int returnVal = foo(5,,8); 

In other words, I want to provide `x` and `z`, but I want to use the default for `Y`, `optionalY = 1.`

Visual Studio does not like the `,,`

Please help.



How to skip optional parameters in C#?

Example:
<pre><code class="hljs language-arduino">public int foo(int x, int optionalY = 1, int optionalZ = 2) { ... }
</code></pre>
I'd like to call it like this:
<pre><code class="hljs language-ini">int returnVal = foo(5,,8); 
</code></pre>
In other words, I want to provide <code>x</code> and <code>z</code>, but I want to use the default for <code>Y</code>, <code>optionalY = 1.</code>
Visual Studio does not like the <code>,,</code>
Please help.

Firstly, *why* doesn&#39;t `Dictionary&lt;TKey, TValue&gt;` support a single null key?

Secondly, is there an existing dictionary-like collection that does?

I want to store an &quot;empty&quot; or &quot;missing&quot; or &quot;default&quot; `System.Type`, thought `null` would work well for this.

--- 

More specifically, I&#39;ve written this class:

    class Switch
    {
        private Dictionary&lt;Type, Action&lt;object&gt;&gt; _dict;

        public Switch(params KeyValuePair&lt;Type, Action&lt;object&gt;&gt;[] cases)
        {
            _dict = new Dictionary&lt;Type, Action&lt;object&gt;&gt;(cases.Length);
            foreach (var entry in cases)
                _dict.Add(entry.Key, entry.Value);
        }

        public void Execute(object obj)
        {
            var type = obj.GetType();
            if (_dict.ContainsKey(type))
                _dict[type](obj);
        }

        public static void Execute(object obj, params KeyValuePair&lt;Type, Action&lt;object&gt;&gt;[] cases)
        {
            var type = obj.GetType();
          
            foreach (var entry in cases)
            {
                if (entry.Key == null || type.IsAssignableFrom(entry.Key))
                {
                    entry.Value(obj);
                    break;
                }
            }
        }

        public static KeyValuePair&lt;Type, Action&lt;object&gt;&gt; Case&lt;T&gt;(Action action)
        {
            return new KeyValuePair&lt;Type, Action&lt;object&gt;&gt;(typeof(T), x =&gt; action());
        }

        public static KeyValuePair&lt;Type, Action&lt;object&gt;&gt; Case&lt;T&gt;(Action&lt;T&gt; action)
        {
            return new KeyValuePair&lt;Type, Action&lt;object&gt;&gt;(typeof(T), x =&gt; action((T)x));
        }

        public static KeyValuePair&lt;Type, Action&lt;object&gt;&gt; Default(Action action)
        {
            return new KeyValuePair&lt;Type, Action&lt;object&gt;&gt;(null, x =&gt; action());
        }
    }

For switching on types. There are two ways to use it:

1. Statically. Just call `Switch.Execute(yourObject, Switch.Case&lt;YourType&gt;(x =&gt; x.Action()))`
2. Precompiled. Create a switch, and then use it later with `switchInstance.Execute(yourObject)`

Works great *except* when you try to add a default case to the &quot;precompiled&quot; version (null argument exception).

Why doesn&#39;t Dictionary&lt;TKey, TValue&gt; support null key?

I have an array of Floats that need to be converted to a byte array and back to a float[]... can anyone help me do this correctly?  

I&#39;m working with the bitConverter class and found myself stuck trying to append the results.

The reason I&#39;m doing this is so I can save runtime values into a IO Stream.  The target storage is Azure Page blobs in case that matters.  I don&#39;t care about what endian this is stored in, as long as it input matches the output.

   

    static  byte[] ConvertFloatToByteArray(float[] floats)
            {
                byte[] ret = new byte[floats.Length * 4];// a single float is 4 bytes/32 bits
    
                for (int i = 0; i &lt; floats.Length; i++)
                {
                   // todo: stuck...I need to append the results to an offset of ret
                    ret = BitConverter.GetBytes(floats[i]);
    
                }
                return ret;
            }


     static  float[] ConvertByteArrayToFloat(byte[] bytes)
    { //to do }



How do I convert an array of floats to a byte[] and back?

How to calculate the difference in months between two dates in C#?

Is there is equivalent of VB&#39;s `DateDiff()` method in C#. I need to find difference in months between two dates that are years apart. The documentation says that I can use `TimeSpan` like:

    TimeSpan ts = date1 - date2;

but this gives me data in Days. **I don&#39;t want to divide this number by 30** because not every month is 30 days and since the two operand values are quite apart from each other, I am afraid dividing by 30 might give me a wrong value.

Any suggestions?

Difference in months between two dates

I know how to find unused references of a single file by right clicking on the file and selecting the &quot;Find Usages&quot; option. Is there any way I can see or get the list of **all** the unused classes or files in my project ?

Resharper- Find all unused classes

I&#39;m trying to create an abstract class that defines a property with a getter. I want to leave it up to derived classes to decide if they want to implement a setter for the property or not. Is this possible?

What I have so far:

    public abstract class AbstractClass {
        public abstract string Value { get; }
        public void DoSomething() {
            Console.WriteLine(Value);
        }
    }

    public class ConcreteClass1 : AbstractClass {
        public override string Value { get; set; }
    }

    public class ConcreteClass2 : AbstractClass {
        private string _value;
        public override string Value {
            get { return _value; }
        }
        public string Value {
            set { _value = value; }
        }
    }

    public class ConcreteClass3 : AbstractClass {
        private string _value;
        public override string Value {
            get { return _value; }
        }
        public void set_Value(string value) {
            _value = value;
        }
    }

In `ConcreteClass1`, I get an error on the `set`. It can&#39;t override `set_Value` because no overridable set accessor exists in AbstractClass.

In `ConcreteClass2`, I get an error on both `Value`&#39;s because a member with the same name is already declared.

`ConcreteClass3` doesn&#39;t give an error, but even though Value&#39;s set accessor would be compiled into set_Value, it doesn&#39;t work the other way around. Defining a `set_Value` does not mean that `Value` gets a set accessor. So I can&#39;t assign a value to a ConcreteClass3.Value property. I *can* use ConcreteClass3.set_Value(&quot;value&quot;), but that&#39;s not what I&#39;m trying to achieve here.

Is it possible to have the abstract class demand a public getter, while allowing an optional setter to be defined in a derived class?

_In case you&#39;r wondering, this is just a theoretical question. I don&#39;t have a real situation where something like this is needed. But I can imagine an abstract class that doesn&#39;t care how a property gets set, but that does need to be able to get the property._

Abstract property with public getter, define private setter in concrete class possible?

I noticed that with the optional parameters in C# 4 if you specify an  optional parameter on an interface you ***don,t*** have to make that parameter optional on any implementing class:

    public interface MyInterface
    {
    	void TestMethod(bool flag = false);
    }
    
    public class MyClass : MyInterface
    {
    	public void TestMethod(bool flag)
    	{
    	    Console.WriteLine(flag);
    	}
    }

and therefore:

    var obj = new MyClass();    	
    obj.TestMethod(); // compiler error

    var obj2 = new MyClass() as MyInterface;
    obj2.TestMethod(); // prints false

Does anyone know why optional parameters are designed to work this way?

On one hand I suppose the ability to override any default values specified on the interfaces is useful though to be honest I&#39;m not sure if you should even be able to specify default values on the interface as that should be an implementation decision.

On the other hand, this disconnect means you can&#39;t always use the concrete class and the interface interchangeably. This of course, wouldn&#39;t be a problem if the default value is specified on the implementation, but then if you&#39;re exposing your concrete class as the interface (using some IOC framework to inject the concrete class for instance) then really there&#39;s no point having the default value as the caller will have to always provide it anyway.

Why are C# 4 optional parameters defined on interface not enforced on implementing class?

I wish to say:
 

    public void Problem(Guid optional = Guid.Empty)
    {
    }


But the compiler complains that Guid.Empty is not a compile time constant.

As I don’t wish to change the API I can’t use:

     Nullable&lt;Guid&gt;

How can I default a parameter to Guid.Empty in C#?

I&#39;m having trouble with this piece of code , after i took this class from the main.cpp file and splitted it in to .h and .cpp the compiler started complaining about the default parameters i was using in a void.

&lt;!-- language: cpp --&gt;

    /* PBASE.H */
        class pBase : public sf::Thread {
    private:
    	bool Running;
    
    public:
    	sf::Mutex Mutex;
    	WORD OriginalColor;
    	pBase(){
    		Launch();
    		Running = true;
    		OriginalColor = 0x7;
    	}
    	void progressBar(int , int);
    	bool key_pressed();
    	void setColor( int );
    	void setTitle( LPCWSTR );
    	bool test_connection(){
    		if(Running == false){
    			return 0;
    		}
    		else{
    			return 1;
    		}
    	return 0;
    	}
    	void Stop(){
    		Running = false;
    		if(Running == false) Wait();
    	}
    };

---

&lt;!-- language: cpp --&gt;

        /* PBASE.CPP */
        
        // ... other stuff above
        
        void pBase::setColor( int _color = -1){
        	if(_color == -1){
        		 SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),FOREGROUND_INTENSITY | OriginalColor);
        		 return;
        	}
        	SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),FOREGROUND_INTENSITY | _color);
    
    }


And the error , taken from VC2010


&gt; Error	4	error C2572: &#39;pBase::setColor&#39; : redefinition of default parameter : parameter 1


The compiler is complaining about my default parameters?

Seems like in .NET Framework there is an issue with optional parameters when you override the method. The output of the code below is:
&quot;bbb&quot;
&quot;aaa&quot;
. But the output I&#39;m expecting is:
&quot;bbb&quot;
&quot;bbb&quot;
.Is there a solution for this. I know it can be solved with method overloading but wondering the reason for this. Also the code works fine in Mono.

    class Program
    {
        class AAA
        {
            public virtual void MyMethod(string s = &quot;aaa&quot;)
            {
                Console.WriteLine(s);
            }

            public virtual void MyMethod2()
            {
                MyMethod();
            }
        }

        class BBB : AAA
        {
            public override void MyMethod(string s = &quot;bbb&quot;)
            {
                base.MyMethod(s);
            }

            public override void MyMethod2()
            {
                MyMethod();
            }
        }

        static void Main(string[] args)
        {
            BBB asd = new BBB();
            asd.MyMethod();
            asd.MyMethod2();
        }
    }

C# optional parameters on overridden methods

    // opt_options is optional
    function foo(a, b, opt_options) {
      // opt_c, opt_d, and opt_e are read from &#39;opt_options&#39;, only c and d have defaults
      var opt_c = &#39;default_for_c&#39;;
      var opt_d = &#39;default_for_d&#39;;
      var opt_e; // e has no default
    
      if (opt_options) {
        opt_c = opt_options.c || opt_c;
        opt_d = opt_options.d || opt_d;
        opt_e = opt_options.e;
      }
    }

The above seems awfully verbose. What&#39;s a better way to handle argument options with default parameters?

Content Type	Original Author	Original Content on Stackoverflow
Question	Ian Davis	View Question on Stackoverflow
Solution 1 - C#	Josiah Ruddell	View Answer on Stackoverflow
Solution 2 - C#	moinudin	View Answer on Stackoverflow
Solution 3 - C#	tofo	View Answer on Stackoverflow
Solution 4 - C#	Peter	View Answer on Stackoverflow

How to skip optional parameters in C#?

C# Problem Overview

C# Solutions

Solution 1 - C#

Solution 2 - C#

Solution 3 - C#

Solution 4 - C#

Remove all arbitary spaces before a line in Vim

Git: Ignoring Version-Controlled Files

Attributions