We Keep Coding

Force my code to use my extension method

I'm using BitFactory logging, which exposes a bunch of methods like this:
public void LogWarning(object aCategory, object anObject)
I've got an extension method that makes this a bit nicer for our logging needs:
public static void LogWarning(this CompositeLogger logger,
string message = "", params object[] parameters)
Which just wraps up some common logging operations, and means I can log like:
Logging.LogWarning("Something bad happened to the {0}. Id was {1}",foo,bar);
But when I only have one string in my params object[], then my extension method won't be called, instead the original method will be chosen.
Apart from naming my method something else, is there a way I can stop this from happening?

The rules about how overloaded methods are resolved to one (or an error) are complex (the C# specification is included with Visual Studio for all the gory details).
But there is one simple rule: extension methods are only considered if there is no possible member that can be called.
Because the signature of two objects will accept any two parameters, any call with two parameters will match that member. Thus no extension methods will considered as possibilities.
You could pass a third parameter (eg. String.Empty) and not use it in the format.
Or, and I suspect this is better, to avoid possible interactions with additions to the library (variable length argument list methods are prone to this) rename to LogWarningFormat (akin to the naming of StringBuffer.AppendFormat).
PS. there is no point having a default for the message parameter: it will never used unless you pass no arguments: but that would log nothing.

Declared methods are always preceding extension methods.
If you want to call the extension regardless of the declared method, you have to call it as a regular static method, of the class that declared it.
eg:
LoggerExtensions.LogWarning(Logging, "Something bad happened to the {0}. Id was {1}",foo,bar);
I assume that the extension is declared in a class named LoggerExtensions

Provided that I think a method with a different name is the way to go (easier to read and maintain), as a workaround you could specify parameters as a named parameter:
logger.LogWarning("Something bad happened to the {0}.", parameters: "foo");

How to call another function within the current function when both have same names but different signature?

I have a situation like this:
public static SqlDataReader ReadFromDB(string inputSQLStatement)
{
//Does some actual work here ..
}
public static DataTable ReadFromDB(string inputSQLStatement)
{
return new DataTable().Load(ReadFromDB(inputSQLStatement));
}
basically the second function is trying to call another function with the same name as the calling function, but has a different return type ..
But with the above code, I get the following error on the return line in the second function:
The call is ambiguous between the following methods or properties ...
I thought maybe the compiler can figure out that the return from the second function is doing into a function which takes an SqlDataReader object, so it knows it has to call the version of ReadFromDB(), but I think I need to explicitly specify which version to call explicitly ..
So how can I tackle this ?
EDIT:
Nevermind, I found out my answer. Function overloading by return type is not supported in C#: http://msdn.microsoft.com/en-us/library/aa691131(v=vs.71).aspx

Overloading by return type is not supported as the formal signature of a method doesn't include the return type but only the name of the method and the types of the parameters (Thanks to CAbbot). See here for more info.
In this case you need to name the methods differently, for example:
public static SqlDataReader ReadFromDB(string inputSQLStatement)
{
//Does some actual work here ..
}
public static DataTable ReadDataTableFromDB(string inputSQLStatement)
{
return new DataTable().Load(ReadFromDB(inputSQLStatement));
}

The method signature is unique by its name, parameters length, then if the length is the same, then by their types (and when params is used, there is another situation). The idea is the return of the method does not count into the method signature.
So you will to rename the method, possible:
ReadFromDBIntoTable

The return value does not belong to the signature. You could give the methods different names, like ReadDataTableFromDB, or move them to interfaces that you explicitly implement.

Ambiguous call error, both functions have different return types

I have two overloaded methods, both called FunctionX. One of them returns a Boolean object, and one a predefined class called Logs.
The error I'm getting is: The call is ambiguous between the following methods or properties: 'FunctionX(string)' and 'FunctionX(string)'.
In one of my other methods, I call FunctionX(string), expecting the Log object, but it's throwing this error. I thought the compiler was supposed to look at the return type and figure this out for itself. How can I fix this?

While languages like Perl and Haskell do support overloading by return type, function overloading by return type is not supported by most statically typed languages. So, it is better if you do not make this trivial problem a part of your code.
Added:
You can find more answers in an earlier Stackoverflow discussion here:
Function overloading by return type?

You cannot have more then one function using the same signature e.g.
string Function1(bool t)
int Function1(bool t)
You need to call each function different names, or having different params e.g.
string Function1(bool t)
int Function1(bool t, int g)

You can't overload a method to have different return types. How would the compiler know what to call here?
string Foo() { /* ... */ }
int Foo() { /* ... */ }
object f = Foo();
Language designers need to take all circumstances into account, not only those that are most trivial.

There is no way for the compiler to distinguish between functions with the same method signature except for the return type. And as far as I know no compiler can that is strongly typed. You must change the signature in some way. On option is to use a generic function and provide the return type.

The return type does not partecipating on overloading in C#.
You can, for example:
Declare separate functions FunctionXToLog and FunctionXToBool
FunctionX(string s, out Log logobject), FunctionX(string s, out bool value)
Just to give you a hint.

You cannot have two function with the same signature only differing in return value!

The signature of a method is its name and the types of its parameters - only. Its return type is not part of its signature.
Hence the problem you are having, since the two methods have identical signatures. The compiler does not use the return type, or the type of the object being assigned to, to determine which method to call.
You will have to specify the classname of the method you want (assuming that the two methods are in different classes). Or you will have to provide another parameter for one of the methods, to give it a different signature. Or, finally, you will have to rename one of the methods to make them unambiguous.

C# method call with parameter name and colon

I've begun to notice at times when I'm making method calls in C# that the names of the parameters for the method I'm calling will show up in the intellisense list appended with a colon, and that I can then format the method call thusly:
MethodCall(parameter1:value1, parameter2:value2);
Is this a new language feature? It reminds me of the way you can call stored procedures in SQL and specify parameter names like so:
spDoSomeStuff #param1 = 1, #param2 = 'other param'
Is this a similar feature? If so, to what end? If not, what is it and what is it to be used for.

It's a new feature. See here: http://msdn.microsoft.com/en-us/library/dd264739.aspx
Named parameters are standard in ObjectiveC for instance. It takes some time to get used to them but they are a good thing. Only from looking you can tell what a parameter is meant for.

It is worth mentioning, unlike optional parameters, you can skip certain arguments and pass only the parameters you are interested in.
public void Example(int required, string StrVal = "default", int IntVal = 0)
{
// ...
}
public void Test()
{
// This gives compiler error
// Example(1, 10);
// This works
Example(1, IntVal:10);
}

Named parameters allow you explicitly set the value of arguments in a custom order independent of the signature. Method signatures are defined by the argument types, ie, Foo( int i, bool b ), which will only accept arguments of type int and bool in that order. Named arguments allow you to pass b first and i second.

Scott Gu has introduced this new feature in his blog:
Optional Parameters and Named Arguments in C# 4

It's the Named and Optional Parameters that came in with C# 4.

Method parameter with strongly typed Enum type

Consider the following code
enum HorizontalAlignment { Left, Middle, Right };
enum VerticleAlignment { Top, Middle, Bottom };
function OutputEnumValues (Type enumType)
{
foreach (string name in Enum.GetNames(typeof(enumType)))
{
Console.WriteLine(name);
}
}
Which can be called like
OutputEnumValues (typeof(HorizontalAlignment));
OutputEnumValues (typeof(VerticleAlignment ));
But I could inadvertantly call, for example
OutputEnumValues (typeof(int));
And this will compile but fail at runtime at Enum.GetNames()
Any way of writing the method signature to catch this sort of problem at compile time - i.e. only accepting enum types in OutputEnumValues?

Every enum type is just an integer (which can be 8-, 16-, 32- or 64-bit and signed or unsigned). You can cast the integer 0 to any enum type, and it will become a value that is statically typed to the enum.
Furthermore, you can have a parameter of type Enum to ensure that only enum values are passed in, without knowing the actual enum type.
Thus, my solution looks like this:
public static void OutputEnumValues(Enum example)
{
foreach (string name in Enum.GetNames(example.GetType()))
{
Console.WriteLine(name);
}
}
and then:
OutputEnumValues((HorizontalAlignment) 0);
OutputEnumValues((VerticalAlignment) 0);
This works for all enum types no matter their underlying integer type.

What you really want here is a Generic method that could constrain to a Enum type. However, that isn't possible in C#.
Jon Skeet has an answer for this very problem in this thread: Anyone know a good workaround for the lack of an enum generic constraint?
For your method what you really want is
public void OutputEnumValues<T>() where T : HorizontalAlignment
{
foreach (string name in Enum.GetNames(typeof(T)))
{
Console.WriteLine(name);
}
}
But that constraint won't work, unless you use Jon's suggestion.

I don't think that this is possible in C#.
You could instead use an extension method on Enum, but this would require you to call it on an instance rather than the type itself which may not be desirable.
An alternative solution using generics that gets you part of the way is to constraint to structs:
public static void OutputValues<T>() where T : struct
{
if (!typeof(T).IsEnum)
throw new NotSupportedException("Argument must be an enum.");
// code here...
}
This will give a compile time error if you try to call it with a class but a runtime error if you call it with a struct that is not an Enum.

I don't see the "problem" as you state it.
You define your method to take a Type object. To clients, any Type would seem sufficient. However, you then assume that the argument is actually an enumeration. The bug is in your method itself. The method itself is contrived anyway, so it's impossible to get an idea of the problem you are actually trying to solve with code like this.
Then again, the name of your method makes it fairly obvious that the argument should be an enum value. You could consider that a contract, and if clients of the code violate that contract than it will blow up in their faces. Any API includes methods that you can send bad data to.