I pieced together a solution based on [How to evaluate a lambda expression][SO1].

You can [`Compile`][compile] the expression to produce the runnable function inside of it.



    Dim func = lambda.Compile()
    Dim output = func(Me)

---

Since I'm still working my way through lambdas, here's a little more by way of explanation:

Inside the Expression, we declared the function signature to look like this `Func(Of T, Object)`  
When we called the method, we told the function evaluation to behave like this `x => x.Bar.Car`

Compiling will give us a new function, stored as a local variable, that will behave like this:



    Function Anonymous(x as T) As Object
        Return x.Bar.Car
    End

**So we haven't actually passed in the instance at all**.  We've just passed in the definition for what should happen when we call this anonymous function and pass in something of type T.  

So we still need to pull in `Me`. In this case, because this function happens to be sitting inside the same class, we cheated a little since the method already had access to the instance variables.  If it was abstracted out somewhere else, the instance itself would have to be passed in as an additional parameter.


[SO1]: https://stackoverflow.com/q/19992057/1366033
[compile]: http://msdn.microsoft.com/en-us/library/bb345362(v=vs.110).aspx

I'm trying to build a string for a class that contains a list of all it's property names and their respective values for that instance.

Per the question [Get Property Info from an object without giving the property name as string][SO1], I'm getting the property name by using an `Expression` of Type `Func` Of Type `T, Object` like this:



    Private Function GetPropertyValuePair(Of T)(lambda As Expression(Of Func(Of T, Object))) As String
        Dim body As Expression = lambda
    
        'ensure we have the right type of thing
        If TypeOf body Is LambdaExpression Then body = DirectCast(body, LambdaExpression).Body
        If TypeOf body Is UnaryExpression Then body = DirectCast(body, UnaryExpression).Operand
        If body.NodeType <> ExpressionType.MemberAccess Then Throw New InvalidOperationException()
    
        'get property info
        Dim memberInfo = DirectCast(body, MemberExpression).Member
        Dim propInfo = DirectCast(memberInfo, PropertyInfo)
    
        Return propInfo.Name + " - " + propInfo.GetValue(Me, Nothing)
    End Function

In this manner, I'm getting the current value by taking the `PropertyInfo`, and using `GetValue` which searches the current instance for that property.

Then I can call it like this:



    GetPropertyValuePair(Of Foo)(Function(x) x.Bar)

Which will produce:

    Bar - WhateverTheValueIsForBar

**The problem** is when I have is when the property is *nested*, `GetValue` will throw the exception:

> Object does not match target type.

For example, in running the following expression: 

    GetPropertyValuePair(Of Foo)(Function(x) x.Bar.Car)

The property info will be of of type `Car`, which is not found directly on `Foo`.

Can I get the instance value from the original lambda expression without having to do the search with GetValue in the first place?

This is possible with the MVC `@Html.EditorFor` helper, so there must be some mechanism for delivering the value of the passed in function for something like this:

    @Html.EditorFor(Function(model) model.Bar.Car)

Any Ideas?

[SO1]: https://stackoverflow.com/q/16777292/1366033

Get value of nested property passed through a lambda expression

I cannot find any any library that will do this inline and modify an already finalized zip.  Here's a brute force approach that goes through the following steps:

1. Create Temp Directory
2. Extract Zip to Temp Dir
3. Delete Original Zip
4. Build Archive and seed with Temp Dir
5. Callback to append any additional files
6. Finalize Archive
7. Delete Temp Directory

It uses [**extract-zip**][1]  to unpack the zip and [**archiver**][2] to bundle it back up.

You can see the full source code at this repo [KyleMit/**append-zip**][3]

### `appendZip.js`

```js
// require modules
const fs = require('fs');
const fsp = fs.promises
const archiver = require('archiver');
const extract = require('extract-zip')

async function appendZip(source, callback) {
    try {
        let tempDir = source + "-temp"

        // create temp dir (folder must exist)
        await fsp.mkdir(tempDir, { recursive: true })

        // extract to folder
        await extract(source, { dir: tempDir })

        // delete original zip
        await fsp.unlink(source)

        // recreate zip file to stream archive data to
        const output = fs.createWriteStream(source);
        const archive = archiver('zip', { zlib: { level: 9 } });

        // pipe archive data to the file
        archive.pipe(output);

        // append files from temp directory at the root of archive
        archive.directory(tempDir, false);

        // callback to add extra files
        callback.call(this, archive)

        // finalize the archive
        await archive.finalize();

        // delete temp folder
        fs.rmdirSync(tempDir, { recursive: true })

    } catch (err) {
        // handle any errors
        console.log(err)
    }
}
```

### Usage

```js
async function main() {
    let source = __dirname + "/functions/func.zip"

    await appendZip(source, (archive) => {
        archive.file('data.json');
    });
}
```

In the callback, you can append files to the archive using any of the methods available with [node-archiver][4], for example:

```js
// append a file from stream
const file1 = __dirname + '/file1.txt';
archive.append(fs.createReadStream(file1), { name: 'file1.txt' });

// append a file from string
archive.append('string cheese!', { name: 'file2.txt' });

// append a file from buffer
const buffer3 = Buffer.from('buff it!');
archive.append(buffer3, { name: 'file3.txt' });

// append a file
archive.file('file1.txt', { name: 'file4.txt' });

// append files from a sub-directory and naming it `new-subdir` within the archive
archive.directory('subdir/', 'new-subdir');

// append files from a sub-directory, putting its contents at the root of archive
archive.directory('subdir/', false);

// append files from a glob pattern
archive.glob('subdir/*.txt');
```

## Further Reading

* [How to add my file to an existing zip-folder using node-js in lambda?](https://stackoverflow.com/q/49669155/1366033)
* [Nodejs and update file inside zip archive](https://stackoverflow.com/q/55191756/1366033)
* [Appending file to zip in nodejs](https://stackoverflow.com/q/19718504/1366033)
* [Adding files into existing zipped archive with NodeJs zip-stream or archiver module](https://stackoverflow.com/q/22902901/1366033)
* [create a zip archive and unzip it in node.js](https://stackoverflow.com/q/5754153/1366033)

[1]: https://www.npmjs.com/package/extract-zip
[2]: https://www.npmjs.com/package/archiver
[3]: https://github.com/KyleMit/append-zip
[4]: https://www.archiverjs.com/archiver

I have a zip folder downloaded from s3 bucket. Now I have a json file in my code, and I want to add my JSON file to an existing zip file using node js code.

Is there any pre existing module for doing this in node js?

I tried [easy-zip][1], but I was not able to add the file to an existing zip-folder.

Any idea on this?

[1]: https://www.npmjs.com/package/easy-zip


How to add my file to an existing zip-folder using node-js in lambda?

### Problem

The problem is the actual [lambda expression][1] itself `() => $"Hello, {name}"` does not actually have a type (*yet*).  

It is only typed once it's cast to either:

* A [delegate][2] of type [`Func`][3] or [`Action`][4]
* Or an [expression tree][5] of type [`Expression`][8] (which can then be compiled to a delegate)

### Solution in C#10

[C#10][6] made several [lambda improvements][7] including an [inferred delegate type][9], meaning C# can now determine (infer) that the lambda is going to be used as a delegate function - so the original syntax is available upon **upgrade to C#10**:

```cs
var sayHello = () => $"Hello, {name}";
```

### Previous Solutions

If you can't upgrade to C#10, there are a couple ways you can explicitly type the lambda.

You can provide an explicit type instead of using `var`:

```cs
Func<string> sayHello = () => $"Hello, {name}";
```

Or you can use the func constructor to type the expression:

```cs
var sayHello = new Func<string>(() => $"Hello, {name}");
```

[**Demo in .NetFiddle**][12]

### Further Reading

* [delegate keyword vs. lambda notation][10]
* [How to return value with anonymous method?][11]

[1]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/lambda-expressions 
[2]: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/delegates/
[3]: https://learn.microsoft.com/en-us/dotnet/api/system.func-1?view=net-6.0
[4]: https://learn.microsoft.com/en-us/dotnet/api/system.action?view=net-6.0
[5]: https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/expression-trees/
[6]: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-10
[7]: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/lambda-improvements
[8]: https://learn.microsoft.com/en-us/dotnet/api/system.linq.expressions.expression?view=net-6.0
[9]: https://github.com/dotnet/csharpstandard/blob/standard-v6/standard/expressions.md#1116-anonymous-function-expressions
[10]: https://stackoverflow.com/q/299703/1366033
[11]: https://stackoverflow.com/q/10520892/1366033
[12]: https://dotnetfiddle.net/nhcZmb

I'm trying to write the following code:

```cs
var name = "Kyle";
var sayHello = () => $"Hello, {name}";
Console.WriteLine(sayHello());
```

But I get the error:

```none
Feature 'inferred delegate type' is not available in C# 9.0.
```

What does that mean and how can I fix it?