public void ListGroupMembers()
{
// Snippet: ListGroupMembers(string,string,int?,CallSettings)
// Create client
GroupServiceClient groupServiceClient = GroupServiceClient.Create();
// Initialize request argument(s)
string formattedName = GroupServiceClient.FormatGroupName("[PROJECT]", "[GROUP]");
// Make the request
IPagedEnumerable <ListGroupMembersResponse, MonitoredResource> response =
groupServiceClient.ListGroupMembers(formattedName);
// Iterate over all response items, lazily performing RPCs as required
foreach (MonitoredResource item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <MonitoredResource> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (MonitoredResource item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
public void ListGroupStats()
{
// Snippet: ListGroupStats(string,QueryTimeRange,string,int?,CallSettings)
// Create client
ErrorStatsServiceClient errorStatsServiceClient = ErrorStatsServiceClient.Create();
// Initialize request argument(s)
string formattedProjectName = ErrorStatsServiceClient.FormatProjectName("[PROJECT]");
QueryTimeRange timeRange = new QueryTimeRange();
// Make the request
IPagedEnumerable <ListGroupStatsResponse, ErrorGroupStats> response =
errorStatsServiceClient.ListGroupStats(formattedProjectName, timeRange);
// Iterate over all response items, lazily performing RPCs as required
foreach (ErrorGroupStats item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <ErrorGroupStats> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (ErrorGroupStats item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
public void WithFixedSize()
{
string projectId = _fixture.ProjectId;
string pageTokenFromRequest = "";
// Sample: WithFixedSize
PublisherClient client = PublisherClient.Create();
string projectName = PublisherClient.FormatProjectName(projectId);
IPagedEnumerable <ListTopicsResponse, Topic> topics = client.ListTopics(projectName, pageTokenFromRequest);
IEnumerable <FixedSizePage <Topic> > fixedSizePages = topics.AsPages().WithFixedSize(3);
// With fixed size pages, if there are no more resources, there are no more pages.
FixedSizePage <Topic> nextPage = fixedSizePages.FirstOrDefault();
if (nextPage != null)
{
// In a web application, this would be a matter of including the topics in the web page.
foreach (Topic topic in nextPage)
{
Console.WriteLine(topic.Name);
}
// ... and embedding the next page token into a "next page" link.
Console.WriteLine($"Next page token: {nextPage.NextPageToken}");
}
// End sample
}
/// <summary>
/// Lists the subtasks matching the specified filter options.
/// </summary>
/// <param name="options">The options to use when querying for subtasks.</param>
/// <returns>The subtasks matching the specified filter options.</returns>
public IEnumerable <PSSubtaskInformation> ListSubtasks(ListSubtaskOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
string taskId = options.Task == null ? options.TaskId : options.Task.Id;
string verboseLogString = string.Format(Resources.GetSubtaskNoFilter, taskId);
WriteVerbose(verboseLogString);
IPagedEnumerable <SubtaskInformation> subtasks = null;
if (options.Task != null)
{
subtasks = options.Task.omObject.ListSubtasks(additionalBehaviors: options.AdditionalBehaviors);
}
else
{
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
subtasks = jobOperations.ListSubtasks(options.JobId, options.TaskId, additionalBehaviors: options.AdditionalBehaviors);
}
Func <SubtaskInformation, PSSubtaskInformation> mappingFunction = s => { return(new PSSubtaskInformation(s)); };
return(PSPagedEnumerable <PSSubtaskInformation, SubtaskInformation> .CreateWithMaxCount(
subtasks, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
public async Task ListJobSchedulesWithRetry()
{
TimeSpan deltaBackoff = TimeSpan.FromSeconds(1);
const int maxRetries = 3;
int callCount = 0;
using (var client = BatchClient.Open(this.credentials))
{
client.JobScheduleOperations.CustomBehaviors.Add(new RequestInterceptor(
(req) =>
{
//I wish I didn't have to cast here
var stronglyTypedRequest = (BatchRequest <
JobScheduleListOptions,
AzureOperationResponse <IPage <ProxyModels.CloudJobSchedule>, JobScheduleListHeaders> >)req;
stronglyTypedRequest.ServiceRequestFunc = (token) =>
{
++callCount;
throw new TimeoutException();
};
}));
client.JobScheduleOperations.CustomBehaviors.Add(new RetryPolicyProvider(new LinearRetry(deltaBackoff, maxRetries)));
await Assert.ThrowsAsync <TimeoutException>(async() =>
{
IPagedEnumerable <CloudJobSchedule> schedules = client.JobScheduleOperations.ListJobSchedules();
await schedules.GetPagedEnumerator().MoveNextAsync();
});
Assert.Equal(maxRetries + 1, callCount);
}
}
static CloudJob AddCloudJob(BatchClient client, string code)
{
var poolId = "applicationpool" + code;
var jobId = "cloudjob" + code;
IPagedEnumerable <CloudJob> jobs = client.JobOperations.ListJobs();
foreach (CloudJob job in jobs)
{
if (job.Id.Equals(jobId))
{
Console.WriteLine("Job already available for id : " + job.Id);
return(job);
}
}
CloudJob newJob = client.JobOperations.CreateJob();
newJob.Id = jobId;
newJob.PoolInformation = new PoolInformation()
{
PoolId = poolId
};
newJob.Commit();
Console.WriteLine("Created the Cloud job for Code : " + code);
return(newJob);
}
public void ListSubscriptions()
{
// Snippet: ListSubscriptions(string,string,int?,CallSettings)
// Create client
SubscriberClient subscriberClient = SubscriberClient.Create();
// Initialize request argument(s)
string formattedProject = SubscriberClient.FormatProjectName("[PROJECT]");
// Make the request
IPagedEnumerable <ListSubscriptionsResponse, Subscription> response =
subscriberClient.ListSubscriptions(formattedProject);
// Iterate over all response items, lazily performing RPCs as required
foreach (Subscription item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <Subscription> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Subscription item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
public void ListOperations()
{
// Snippet: ListOperations(string,string,string,int?,CallSettings)
// Create client
OperationsClient operationsClient = OperationsClient.Create();
// Initialize request argument(s)
string name = "";
string filter = "";
// Make the request
IPagedEnumerable <ListOperationsResponse, Operation> response =
operationsClient.ListOperations(name, filter);
// Iterate over all response items, lazily performing RPCs as required
foreach (Operation item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <Operation> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Operation item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
public void GetPoolsListTest()
{
using (var client = FakeBatchClient.ConnectWithFakeCredentials(ClientUnitTestCommon.DummyBaseUrl))
{
client.FakeProtocolLayer.ListPoolsHandler = (skipToken, behaviors) => Task.FromResult(
new AzureOperationResponse <IPage <ProxyModels.CloudPool>, ProxyModels.PoolListHeaders>()
{
Body = new FakePage <ProxyModels.CloudPool>(new List <ProxyModels.CloudPool>()
{
new ProxyModels.CloudPool {
DisplayName = "batch-test"
},
new ProxyModels.CloudPool {
DisplayName = "foobar", CurrentOSVersion = "3", AllocationState = ProxyModels.AllocationState.Steady
},
})
});
IPagedEnumerable <Microsoft.Azure.Batch.CloudPool> asyncPools = client.PoolOperations.ListPools();
var pools = new List <Microsoft.Azure.Batch.CloudPool>(asyncPools);
Assert.Equal(2, pools.Count);
Assert.Equal("batch-test", pools[0].DisplayName);
Assert.Equal("foobar", pools[1].DisplayName);
// enums are in the same namespace.
Assert.Equal(AllocationState.Steady, pools[1].AllocationState);
}
}
public void ListLogMetrics()
{
// Snippet: ListLogMetrics(string,string,int?,CallSettings)
// Create client
MetricsServiceV2Client metricsServiceV2Client = MetricsServiceV2Client.Create();
// Initialize request argument(s)
string formattedParent = MetricsServiceV2Client.FormatParentName("[PROJECT]");
// Make the request
IPagedEnumerable <ListLogMetricsResponse, LogMetric> response =
metricsServiceV2Client.ListLogMetrics(formattedParent);
// Iterate over all response items, lazily performing RPCs as required
foreach (LogMetric item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <LogMetric> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (LogMetric item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
public void ListTraces()
{
// Snippet: ListTraces(string,string,int?,CallSettings)
// Create client
TraceServiceClient traceServiceClient = TraceServiceClient.Create();
// Initialize request argument(s)
string projectId = "";
// Make the request
IPagedEnumerable <ListTracesResponse, Trace> response =
traceServiceClient.ListTraces(projectId);
// Iterate over all response items, lazily performing RPCs as required
foreach (Trace item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <Trace> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (Trace item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
/// <summary>
/// Lists the pool node counts matching the specified filter options.
/// </summary>
/// <param name="options">The options to use when listing pool node counts.</param>
/// <returns>The pool node counts matching the specified filter.</returns>
public IEnumerable <PSPoolNodeCounts> ListPoolNodeCounts(ListPoolNodeCountsOptions options)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
ODATADetailLevel detailLevel = null;
const string filterStringFormat = "(poolId eq '{0}')";
if (!string.IsNullOrEmpty(options.PoolId))
{
detailLevel = new ODATADetailLevel(string.Format(filterStringFormat, options.PoolId));
}
else if (options.Pool != null)
{
detailLevel = new ODATADetailLevel(string.Format(filterStringFormat, options.Pool.Id));
}
IPagedEnumerable <PoolNodeCounts> poolNodeCounts = options.Context.BatchOMClient.PoolOperations.ListPoolNodeCounts(
detailLevel, options.AdditionalBehaviors);
Func <PoolNodeCounts, PSPoolNodeCounts> mappingFunction = p => { return(new PSPoolNodeCounts(p)); };
return(PSPagedEnumerable <PSPoolNodeCounts, PoolNodeCounts> .CreateWithMaxCount(poolNodeCounts, mappingFunction,
options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
public static MvcHtmlString PagerStats(this HtmlHelper htmlHelper, IPagedEnumerable list, string singular)
{
var plural = Inflector.Pluralize(singular);
var output = string.Empty;
switch (list.TotalRecords)
{
case 0 :
output = string.Format("There are <strong>0</strong> {0}.", plural);
break;
case 1 :
output = string.Format("There is <strong>1</strong> {0}.", singular);
break;
default :
output = string.Format(
"There are <strong>{0}</strong> {1}. Displaying {2} <strong>{3}</strong> to <strong>{4}</strong>.",
list.TotalRecords,
plural,
singular,
(list.PageSize * list.Page) - (list.PageSize - 1),
(list.PageSize * list.Page) > list.TotalRecords ? list.TotalRecords : list.PageSize * list.Page);
break;
}
return MvcHtmlString.Create(output);
}
public void ListLogEntries()
{
// Snippet: ListLogEntries(IEnumerable<string>,string,string,string,int?,CallSettings)
// Create client
LoggingServiceV2Client loggingServiceV2Client = LoggingServiceV2Client.Create();
// Initialize request argument(s)
IEnumerable <string> projectIds = new List <string>();
string filter = "";
string orderBy = "";
// Make the request
IPagedEnumerable <ListLogEntriesResponse, LogEntry> response =
loggingServiceV2Client.ListLogEntries(projectIds, filter, orderBy);
// Iterate over all response items, lazily performing RPCs as required
foreach (LogEntry item in response)
{
// Do something with each item
Console.WriteLine(item);
}
// Or iterate over fixed-sized pages, lazily performing RPCs as required
int pageSize = 10;
foreach (FixedSizePage <LogEntry> page in response.AsPages().WithFixedSize(pageSize))
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (LogEntry item in page)
{
Console.WriteLine(item);
}
}
// End snippet
}
public static async Task PrintNodeTasksAsync(BatchClient batchClient, string poolId)
{
Console.WriteLine("Listing Node Tasks");
Console.WriteLine("==================");
ODATADetailLevel nodeDetail = new ODATADetailLevel(selectClause: "id,recentTasks");
IPagedEnumerable <ComputeNode> nodes = batchClient.PoolOperations.ListComputeNodes(poolId, nodeDetail);
await nodes.ForEachAsync(node =>
{
Console.WriteLine();
Console.WriteLine(node.Id + " tasks:");
if (node.RecentTasks != null && node.RecentTasks.Any())
{
foreach (TaskInformation task in node.RecentTasks)
{
Console.WriteLine("\t{0}: {1}", task.TaskId, task.TaskState);
}
}
else
{
// No tasks found for the node
Console.WriteLine("\tNone");
}
}).ConfigureAwait(continueOnCapturedContext: false);
Console.WriteLine("==================");
}
/// <summary>
/// Lists the job prep and release status matching the specified filter options.
/// </summary>
/// <param name="options">The Batch account context.</param>
public IEnumerable <PSJobPreparationAndReleaseTaskExecutionInformation> ListJobPreparationAndReleaseStatus(ListJobPreparationAndReleaseStatusOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
string jobId = options.JobId ?? options.Job.Id;
if (jobId == null)
{
throw new ArgumentNullException(nameof(jobId));
}
WriteVerbose(string.Format(Resources.GetJobPreparationAndReleaseStatus, jobId));
JobOperations jobOperations = options.Context.BatchOMClient.JobOperations;
ODATADetailLevel getDetailLevel = new ODATADetailLevel(filterClause: options.Filter, selectClause: options.Select, expandClause: options.Expand);
IPagedEnumerable <JobPreparationAndReleaseTaskExecutionInformation> jobPrepAndReleaseDetails =
jobOperations.ListJobPreparationAndReleaseTaskStatus(jobId, getDetailLevel, additionalBehaviors: options.AdditionalBehaviors);
Func <JobPreparationAndReleaseTaskExecutionInformation, PSJobPreparationAndReleaseTaskExecutionInformation> mappingFunction =
j => new PSJobPreparationAndReleaseTaskExecutionInformation(j);
return(PSPagedEnumerable <PSJobPreparationAndReleaseTaskExecutionInformation, JobPreparationAndReleaseTaskExecutionInformation> .CreateWithMaxCount(
jobPrepAndReleaseDetails, mappingFunction, options.MaxCount, () => WriteVerbose(string.Format(Resources.MaxCount, options.MaxCount))));
}
public async Task IfSequenceIsNull_ThenForEachAsyncThrowsArgumentNullException_SyncDelegateOverload()
{
IPagedEnumerable <string> seq = null;
var ex = await Assert.ThrowsAsync <ArgumentNullException>(() => seq.ForEachAsync(_ => { }));
Assert.Equal("source", ex.ParamName);
}
public static PageResult <TDestination> ToPageResult <TSource, TDestination>(this IPagedEnumerable <TSource> source)
where TSource : class
where TDestination : class
{
var items = Mapper.Map <IEnumerable <TSource>, IEnumerable <TDestination> >(source);
return(new PageResult <TDestination>(items, source.TotalCount));
}
/// <summary>
/// Lists the task files associated with this task
/// </summary>
/// <returns></returns>
private async System.Threading.Tasks.Task <List <NodeFile> > ListTaskFilesAsync()
{
IPagedEnumerable <NodeFile> vmFiles = this.Task.ListNodeFiles(recursive: true);
List <NodeFile> results = await vmFiles.ToListAsync();
return(results);
}
public async Task IfSequenceIsNull_ThenToListAsyncThrowsArgumentNullException()
{
IPagedEnumerable <string> seq = null;
var ex = await Assert.ThrowsAsync <ArgumentNullException>(() => seq.ToListAsync());
Assert.Equal("source", ex.ParamName);
}
/// <summary>
/// Lists the files on this ComputeNode.
/// </summary>
/// <returns></returns>
private async Task <List <NodeFile> > ListFilesAsync()
{
IPagedEnumerable <NodeFile> vmFiles = this.ComputeNode.ListNodeFiles(recursive: true);
List <NodeFile> results = await vmFiles.ToListAsync();
return(results);
}
public async Task <IList <NodeAgentSku> > ListNodeAgentSkusAsync()
{
IPagedEnumerable <NodeAgentSku> nodeAgentSkus = this.Service.ListNodeAgentSkus();
IList <NodeAgentSku> results = await nodeAgentSkus.ToListAsync();
return(results);
}
public PagedListResultBuilder <TItem> WithPagedItems(IPagedEnumerable <TItem> items)
{
this.result.Items = items.ToList();
this.result.PageIndex = items.PageIndex;
this.result.PageSize = items.PageSize;
this.result.TotalCount = items.TotalCount;
return(this);
}
/// <summary>
/// Enumerates the <see cref="CloudJob">jobs</see> created under the specified job schedule.
/// </summary>
/// <param name="jobScheduleId">The id of the job schedule.</param>
/// <param name="detailLevel">A <see cref="DetailLevel"/> used for filtering the list and for controlling which properties are retrieved from the service.</param>
/// <param name="additionalBehaviors">A collection of <see cref="BatchClientBehavior"/> instances that are applied to the Batch service request after the <see cref="CustomBehaviors"/> and <paramref name="detailLevel"/>.</param>
/// <returns>An <see cref="IPagedEnumerable{CloudJob}"/> that can be used to enumerate jobs asynchronously or synchronously.</returns>
/// <remarks>This method returns immediately; the jobs are retrieved from the Batch service only when the collection is enumerated.
/// Retrieval is non-atomic; jobs are retrieved in pages during enumeration of the collection.</remarks>
public IPagedEnumerable <CloudJob> ListJobs(string jobScheduleId, DetailLevel detailLevel = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
// set up behavior manager
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
IPagedEnumerable <CloudJob> enumerable = ListJobsImpl(jobScheduleId, bhMgr, detailLevel);
return(enumerable);
}
public async Task <IList <CertificateModel> > GetCertificatesCollectionAsync()
{
IPagedEnumerable <Certificate> certificates = this.Service.ListCertificates(null);
IList <CertificateModel> certificateModels = new List <CertificateModel>();
await certificates.ForEachAsync(item => certificateModels.Add(new CertificateModel(item)));
return(certificateModels);
}
public async Task <IList <PoolModel> > GetPoolCollectionAsync()
{
IPagedEnumerable <CloudPool> pools = this.Service.ListPools(OptionsModel.Instance.ListDetailLevel);
IList <PoolModel> poolModels = new List <PoolModel>();
await pools.ForEachAsync(item => poolModels.Add(new PoolModel(item)));
return(poolModels);
}
public async Task <IList <JobModel> > GetJobCollectionAsync()
{
IPagedEnumerable <CloudJob> jobs = this.Service.ListJobs(OptionsModel.Instance.ListDetailLevel);
List <JobModel> jobModels = new List <JobModel>();
await jobs.ForEachAsync(item => jobModels.Add(new JobModel(item)));
return(jobModels);
}
private async Task <List <ComputeNodeModel> > ListComputeNodesAsync()
{
List <ComputeNodeModel> results = new List <ComputeNodeModel>();
IPagedEnumerable <ComputeNode> jobList = this.Pool.ListComputeNodes();
await jobList.ForEachAsync(item => results.Add(new ComputeNodeModel(this, item)));
return(results);
}
/// <summary>
/// Exposes synchronous and asynchronous enumeration of the files for the node.
/// </summary>
/// <param name="recursive">If true, performs a recursive list of all files of the node. If false, returns only the files at the node directory root.</param>
/// <param name="detailLevel">Controls the detail level of the data returned by a call to the Azure Batch Service.</param>
/// <param name="additionalBehaviors">A collection of BatchClientBehavior instances that are applied after the CustomBehaviors on the current object and after the behavior implementing the DetailLevel.</param>
/// <returns>An instance of IPagedEnumerable that can be used to enumerate objects using either synchronous or asynchronous patterns.</returns>
public IPagedEnumerable <NodeFile> ListNodeFiles(bool?recursive = null, DetailLevel detailLevel = null, IEnumerable <BatchClientBehavior> additionalBehaviors = null)
{
// craft the behavior manager for this call
BehaviorManager bhMgr = new BehaviorManager(this.CustomBehaviors, additionalBehaviors);
IPagedEnumerable <NodeFile> enumerator = this.parentBatchClient.PoolOperations.ListNodeFilesImpl(this.parentPoolId, this.Id, recursive, bhMgr, detailLevel);
return(enumerator);
}
public object GetMeta(IPagedEnumerable instance)
{
return new
{
instance.Page,
instance.TotalPages,
instance.ItemsPerPage
};
}
private async System.Threading.Tasks.Task <List <TaskModel> > ListTasksAsync()
{
List <TaskModel> results = new List <TaskModel>();
IPagedEnumerable <CloudTask> taskList = this.Job.ListTasks(OptionsModel.Instance.ListDetailLevel);
await taskList.ForEachAsync(item => results.Add(new TaskModel(this, item)));
return(results);
}
public object GetMeta(IPagedEnumerable instance)
{
return(new
{
instance.Page,
instance.TotalPages,
instance.ItemsPerPage
});
}
public static MvcHtmlString Pager(this HtmlHelper htmlHelper, IPagedEnumerable list, int maximumNumericLinks, string pagerPreviousClass, string pagerNextClass, string pagerDisabledClass, string pagingNumberClass, string pagingNumberCurrentClass)
{
if (maximumNumericLinks % 2 != 1)
throw new ArgumentException("Value must be an odd number.", "maximumNumericLinks");
var url = new UrlHelper(htmlHelper.ViewContext.RequestContext);
#region Previous Link
var prev = new TagBuilder("div");
prev.AddCssClass("pagerPreviousHolder");
var prevLink = new TagBuilder("a");
prevLink.SetInnerText("<< Prev");
if (list.Page > 1)
prevLink.MergeAttribute("href", url.StateUrl(new { page = list.Page - 1 }));
else
prevLink.AddCssClass(pagerDisabledClass);
prevLink.AddCssClass(pagerPreviousClass);
prev.InnerHtml = prevLink.ToString(TagRenderMode.Normal);
#endregion
#region Numeric Links
var numerics = new TagBuilder("div");
numerics.AddCssClass("pagerNumberHolder");
if (list.TotalPages > 0)
{
int pagingStartNumber = -1;
int pagingEndNumber = -1;
if ((list.TotalPages >= maximumNumericLinks) && (list.Page > (int)Math.Ceiling((double)maximumNumericLinks / 2D)))
pagingStartNumber = list.Page - (int)Math.Floor((double)maximumNumericLinks / 2D);
else
pagingStartNumber = 1;
if (list.TotalPages >= (pagingStartNumber + maximumNumericLinks))
pagingEndNumber = pagingStartNumber + (maximumNumericLinks - 1);
else
{
if (list.TotalPages >= maximumNumericLinks)
pagingStartNumber = list.TotalPages - (maximumNumericLinks - 1);
pagingEndNumber = list.TotalPages;
}
//for (int i = pagingStartNumber; i <= pagingEndNumber; i++)
for (int i = pagingEndNumber; i >= pagingStartNumber; i--)
{
var numberTag = new TagBuilder("a");
numberTag.SetInnerText(i.ToString());
if (i == list.Page)
numberTag.AddCssClass(pagingNumberCurrentClass);
else
numberTag.MergeAttribute("href", url.StateUrl(new { page = i }));
numberTag.AddCssClass(pagingNumberClass);
numerics.InnerHtml = numerics.InnerHtml + numberTag.ToString();
}
}
else
{
//numerics.InnerHtml = " "; // Stops div colapsing
}
#endregion
#region Next Link
var next = new TagBuilder("div");
next.AddCssClass("pagerNextHolder");
var nextLink = new TagBuilder("a");
nextLink.SetInnerText("Next >>");
if (list.Page < list.TotalPages)
nextLink.MergeAttribute("href", url.StateUrl(new { page = list.Page + 1 }));
else
nextLink.AddCssClass(pagerDisabledClass);
nextLink.AddCssClass(pagerNextClass);
next.InnerHtml = nextLink.ToString();
#endregion
return MvcHtmlString.Create(string.Format("<div class=\"pagerHolder\">{0}{3}{0}{2}{0}{1}</div>", Environment.NewLine, prev, numerics, next));
}
public static MvcHtmlString Pager(this HtmlHelper htmlHelper, IPagedEnumerable list)
{
return htmlHelper.Pager(list, 9);
}
public static MvcHtmlString Pager(this HtmlHelper htmlHelper, IPagedEnumerable list, int maximumNumericLinks)
{
return htmlHelper.Pager(list, maximumNumericLinks, "pagerPreviousLink", "pagerNextLink", "disabled", "pagerNumberLink", "current");
}
public static MvcHtmlString PagerStats(this HtmlHelper htmlHelper, IPagedEnumerable list)
{
return htmlHelper.PagerStats(list, "record");
}
