Google Cloud Support v2 API - Class CaseServiceClient (1.2.0)

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
CloseCaseRequest request = new CloseCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
};
// Make the request
Case response = caseServiceClient.CloseCase(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
CloseCaseRequest request = new CloseCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
};
// Make the request
Case response = await caseServiceClient.CloseCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
CloseCaseRequest request = new CloseCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
};
// Make the request
Case response = await caseServiceClient.CloseCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
Case @case = new Case();
// Make the request
Case response = caseServiceClient.CreateCase(parent, @case);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Case @case = new Case();
// Make the request
Case response = caseServiceClient.CreateCase(parent, @case);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
CreateCaseRequest request = new CreateCaseRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    Case = new Case(),
};
// Make the request
Case response = caseServiceClient.CreateCase(request);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
Case @case = new Case();
// Make the request
Case response = caseServiceClient.CreateCase(parent, @case);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
Case @case = new Case();
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(parent, @case);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
Case @case = new Case();
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(parent, @case);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Case @case = new Case();
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(parent, @case);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
Case @case = new Case();
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(parent, @case);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCaseRequest request = new CreateCaseRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    Case = new Case(),
};
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
CreateCaseRequest request = new CreateCaseRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    Case = new Case(),
};
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
Case @case = new Case();
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(parent, @case);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
Case @case = new Case();
// Make the request
Case response = await caseServiceClient.CreateCaseAsync(parent, @case);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
EscalateCaseRequest request = new EscalateCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
    Escalation = new Escalation(),
};
// Make the request
Case response = caseServiceClient.EscalateCase(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
EscalateCaseRequest request = new EscalateCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
    Escalation = new Escalation(),
};
// Make the request
Case response = await caseServiceClient.EscalateCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
EscalateCaseRequest request = new EscalateCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
    Escalation = new Escalation(),
};
// Make the request
Case response = await caseServiceClient.EscalateCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
CaseName name = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]");
// Make the request
Case response = caseServiceClient.GetCase(name);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
GetCaseRequest request = new GetCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
};
// Make the request
Case response = caseServiceClient.GetCase(request);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/cases/[CASE]";
// Make the request
Case response = caseServiceClient.GetCase(name);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
CaseName name = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]");
// Make the request
Case response = await caseServiceClient.GetCaseAsync(name);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
CaseName name = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]");
// Make the request
Case response = await caseServiceClient.GetCaseAsync(name);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
GetCaseRequest request = new GetCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
};
// Make the request
Case response = await caseServiceClient.GetCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
GetCaseRequest request = new GetCaseRequest
{
    CaseName = CaseName.FromOrganizationCase("[ORGANIZATION]", "[CASE]"),
};
// Make the request
Case response = await caseServiceClient.GetCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/cases/[CASE]";
// Make the request
Case response = await caseServiceClient.GetCaseAsync(name);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/cases/[CASE]";
// Make the request
Case response = await caseServiceClient.GetCaseAsync(name);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
// Make the request
PagedEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCases(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Case item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListCasesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCases(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Case item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListCasesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
ListCasesRequest request = new ListCasesRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCases(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Case item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListCasesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
// Make the request
PagedEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCases(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Case item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListCasesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
// Make the request
PagedAsyncEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCasesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Case item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListCasesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedAsyncEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCasesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Case item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListCasesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
ListCasesRequest request = new ListCasesRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCasesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Case item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListCasesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
// Make the request
PagedAsyncEnumerable<ListCasesResponse, Case> response = caseServiceClient.ListCasesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Case item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListCasesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
SearchCaseClassificationsRequest request = new SearchCaseClassificationsRequest { Query = "", };
// Make the request
PagedEnumerable<SearchCaseClassificationsResponse, CaseClassification> response = caseServiceClient.SearchCaseClassifications(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (CaseClassification item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (SearchCaseClassificationsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (CaseClassification item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<CaseClassification> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (CaseClassification item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
SearchCaseClassificationsRequest request = new SearchCaseClassificationsRequest { Query = "", };
// Make the request
PagedAsyncEnumerable<SearchCaseClassificationsResponse, CaseClassification> response = caseServiceClient.SearchCaseClassificationsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((CaseClassification item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((SearchCaseClassificationsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (CaseClassification item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<CaseClassification> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (CaseClassification item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
SearchCasesRequest request = new SearchCasesRequest
{
    Query = "",
    Parent = "",
};
// Make the request
PagedEnumerable<SearchCasesResponse, Case> response = caseServiceClient.SearchCases(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Case item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (SearchCasesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
SearchCasesRequest request = new SearchCasesRequest
{
    Query = "",
    Parent = "",
};
// Make the request
PagedAsyncEnumerable<SearchCasesResponse, Case> response = caseServiceClient.SearchCasesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Case item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((SearchCasesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Case item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Case> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Case item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
Case @case = new Case();
FieldMask updateMask = new FieldMask();
// Make the request
Case response = caseServiceClient.UpdateCase(@case, updateMask);

// Create client
CaseServiceClient caseServiceClient = CaseServiceClient.Create();
// Initialize request argument(s)
UpdateCaseRequest request = new UpdateCaseRequest
{
    Case = new Case(),
    UpdateMask = new FieldMask(),
};
// Make the request
Case response = caseServiceClient.UpdateCase(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
Case @case = new Case();
FieldMask updateMask = new FieldMask();
// Make the request
Case response = await caseServiceClient.UpdateCaseAsync(@case, updateMask);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
Case @case = new Case();
FieldMask updateMask = new FieldMask();
// Make the request
Case response = await caseServiceClient.UpdateCaseAsync(@case, updateMask);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateCaseRequest request = new UpdateCaseRequest
{
    Case = new Case(),
    UpdateMask = new FieldMask(),
};
// Make the request
Case response = await caseServiceClient.UpdateCaseAsync(request);

// Create client
CaseServiceClient caseServiceClient = await CaseServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateCaseRequest request = new UpdateCaseRequest
{
    Case = new Case(),
    UpdateMask = new FieldMask(),
};
// Make the request
Case response = await caseServiceClient.UpdateCaseAsync(request);