Question: ### Question

I've now read a lot about Duck Typing, and I seem to understand the concept.

What I've not understood is, in what case it does effectively make sense to abandon the benefits of strong typified programming to the benefits of Duck Typing. *In what case would one use Duck Typing instead of Interfaces and Inheritance?*

I mean if you anyway need to secure that an object passed to a Method implements certain methods, why shouldn't I simply define an Interface?

Just to be clear, I know how Duck Typing works. I want to know when it really makes sense to use it.

### Clarification:

In which case would you use

```
public bool MyMethod(dynamic obj)

```

instead of

```
public bool MyMethod(ISomeInterface obj)
//or
public bool MyMethod(SomeBaseClass obj)

```

Answer: 
C# has strong typing for a reason. Unless you have a valid reason (such as needing COM interop) to use the `dynamic` type, you should probably avoid it like the plague, or you'll risk turning compile-time problems into runtime problems. `dynamic` is powerful, but easy to abuse. Think long and hard about if you really *need* dynamic typing - if you think there is, there's a chance that you're approaching the problem wrong to begin with, and need to refactor your code.

To specifically answer your question - one potential use case was if you were writing serialisation code and needed to accept a deserialised object, for example a deserialised JSON structure from a web API request. Such methods would need to handle any type given to them, which is a situation in which using `dynamic` is better than the alternative (ie. a truck-load of reflection).

Another example I can think of would be interoperability with languages specifically on the Dynamic Language Runtime (eg. JavaScript, IronPython, IronRuby, ...), and needed to write a method accepting types from such languages.

From [Beginning Visual C# 2012 Programming](//www.wrox.com/WileyCDA/WroxTitle/Beginning-Visual-C-2012-Programming.productCd-1118314417.html):

> 
> For most C# code that you write, avoid the `dynamic` keyword. However, if a situation arises where you *need* to use it, use it and love it - and spare a thought for those poor programmers of the past who didn't have this powerful tool at their disposal.
> 
> 
>
**Duck Typing:**

> 
> Please you do this rather than asking who you are.
> 
> 
> 

**Example:**

> 
> Here coding should be simply define and execution. Example, here are
>  the things that I want the following object do something.
> 
> 
> 

```
    Please("Walk", new Dog());
    Please("Run", new Duck());
    Please("Fly", new Cup());
    Please("Fly", new Bird());
    Please("Fly", new Man());
    Please("Walk", new Man());
    Please("Run", new Man());

```

> 
> This is the result after excuting test.
> 
> 
> 

[![enter image description here](https://i.stack.imgur.com/mTenN.jpg)](https://i.stack.imgur.com/mTenN.jpg)

> 
> So, the above objects will do things that we requesting to do only.
>  Additional, I have added the question to ask them answer who they,
>  too. Here is the code in C#.
> 
> 
> 

```
private void Please(string Action, object Obj)
{
    MethodInfo method = Obj.GetType().GetMethod(Action, Type.EmptyTypes, null);
    if (method != null)
    {
        method.Invoke(Obj, new object[] { });
    }
    else
    {
        Console.WriteLine(string.Format("I can not {0} because {1}", Action, WhoAreYou(Obj)));
    }
}

private string WhoAreYou(object unknown)
{
    string question = "WhoAreYou";
    MethodInfo whoAreYou = unknown.GetType().GetMethod(question, Type.EmptyTypes, null);
    return whoAreYou.Invoke(unknown, new object[] { }).ToString();
}

```