Net Collections
Find Home Decor, Gifts & Apparel, and Seasonal decorations at Collections Etc. We offer over 3,000 items $14.99 or less.
In a nutshell :
Our members download database is updated on a daily basis.Take advantage of our limited time offer and gain access to unlimited downloads for FREE! We currently have 299,787 full downloads including categories such as: software, movies, games, tv, adult movies, music, ebooks, apps and much more.
1. Gross BO Collection - This is the collective sum of the ticket value sold at the counter.
2. Net BO Collection - This is Gross BO minus entertainment tax.
3. Share - Usually refers to the distributor share from the Net BO Collection. This is usually near 50% f the Net box office collection.
In Detail,
Gross and Net BO
Suppose 100 tickets were sold for a movie in 2 cinemas A and B, A charging Rs. 200 per ticket selling 40 and B charging 120 selling 60 tickets,
Gross BOC = 200 x 40 + 120 x 60 = 15200, 8000 from A and 7200 from B. So A performed better than B, right? Not quite...
The Problem - If we account for the entire collection from all over India, Gross BO won't be and apples to apples comparison as different states charges different rates of entertainment tax. Eg Assam, Himachal Pradesh, Jammu & Kashmir, Punjab and Uttaranchal doesnt charge any tax on movies. Rajasthan Charges 0% on Rajasthani Films and 30% ET on all others whereas Kerala charges flat 30% on all films. The highest entertainment tax rate is for Jharkhand at a whopping 110%.
Thus, a movie might have a huge box office collection in a territory but the distributor might be running losses due to high tax rate.
Suppose Cinema A was in Kerala and Cinema B was in Punjab.
Ticket Price A = 200 = X + 0.3X --> X = 153.85 and 0.3X = 46.15
X is what the people associated with the movie makes, including the producers, distributors and the cinemas.
In Cinema B, X = Ticket Price since there is no tax.
So if you add up all the Net BO from all the territory, we get the real picture of how much money the movie made.
In our above example of A and B,
![Net Collections Net Collections](https://pbs.twimg.com/media/DKB2RnOX0AALRBE.jpg)
Net BO from Cinema A = 153.85 *40 = 6154
Net Collections Rate
Net BO from Cinema B = 120 * 60 = 7200
Total Net Box Office = 13354.
Thus, cinema B actually made more money for the producers than cinema A.
Whenever the producer has to report the earnings to the media, he would prefer Gross over Net as it is an inflated figure to trick the public into believing that the movie is a hit. But for accounting purposes, Net BO is what is used.
Now comes the distributor share.
Usually, the producer of the movie would sell the rights of the movie to distributors across the country either for a lump sum or on a revenue sharing basis. In many cases, the producer might also own a distribution division which takes care of this in all major regions of the country. This the distributor share is partly or wholly what the makers of the film earn.
The distributor share in India are as follows:
Multiplexes:
Week 1 : 50%
Week 2: 42%
Week 3 : 37%
After Week 3 : 30%
The higher first week share is one of the reasons why distributors try to squeeze in as many screens as possible in the first week and push for a higher box office collection.
For single screens, its usually in the range of 70%. But it is common for single screens to pay a lump sum.
Our movie has a earned Net BO of Rs 13354 from 2 cinemas. This money needs to be divided among two parties - the distributor and the cinema owner. Suppose Cinema A was a multiplex and B was a single screen.
Distributor Share from A : 50% of 6154 = Rs. 3077
Distributor Share from B : 70% of 7200 = Rs. 5040
Total Distributor Share = Rs. 8117 out of a total Gross BO of Rs. 15200.
A movie as a rule of thumb requires to earn twice its production and marketing budget at the box office to break even and much higher to make a healthy profit.
Hope this helps.
Useful Links :
-->For many applications, you want to create and manage groups of related objects. There are two ways to group objects: by creating arrays of objects, and by creating collections of objects.
Arrays are most useful for creating and working with a fixed number of strongly-typed objects. For information about arrays, see Arrays.
Collections provide a more flexible way to work with groups of objects. Unlike arrays, the group of objects you work with can grow and shrink dynamically as the needs of the application change. For some collections, you can assign a key to any object that you put into the collection so that you can quickly retrieve the object by using the key.
A collection is a class, so you must declare an instance of the class before you can add elements to that collection.
If your collection contains elements of only one data type, you can use one of the classes in the System.Collections.Generic namespace. A generic collection enforces type safety so that no other data type can be added to it. When you retrieve an element from a generic collection, you do not have to determine its data type or convert it.
Note
For the examples in this topic, include using directives for the System.Collections.Generic
and System.Linq
namespaces.
In this topic
Using a Simple Collection
The examples in this section use the generic List<T> class, which enables you to work with a strongly typed list of objects.
The following example creates a list of strings and then iterates through the strings by using a foreach statement.
If the contents of a collection are known in advance, you can use a collection initializer to initialize the collection. For more information, see Object and Collection Initializers.
The following example is the same as the previous example, except a collection initializer is used to add elements to the collection.
You can use a for statement instead of a foreach
statement to iterate through a collection. You accomplish this by accessing the collection elements by the index position. The index of the elements starts at 0 and ends at the element count minus 1.
The following example iterates through the elements of a collection by using for
instead of foreach
.
The following example removes an element from the collection by specifying the object to remove.
The following example removes elements from a generic list. Instead of a foreach
statement, a for statement that iterates in descending order is used. This is because the RemoveAt method causes elements after a removed element to have a lower index value.
For the type of elements in the List<T>, you can also define your own class. In the following example, the Galaxy
class that is used by the List<T> is defined in the code.
Kinds of Collections
Many common collections are provided by the .NET Framework. Each type of collection is designed for a specific purpose.
Some of the common collection classes are described in this section:
System.Collections.Generic classes
System.Collections.Concurrent classes
System.Collections classes
System.Collections.Generic Classes
You can create a generic collection by using one of the classes in the System.Collections.Generic namespace. A generic collection is useful when every item in the collection has the same data type. A generic collection enforces strong typing by allowing only the desired data type to be added.
The following table lists some of the frequently used classes of the System.Collections.Generic namespace:
Class | Description |
---|---|
Dictionary<TKey,TValue> | Represents a collection of key/value pairs that are organized based on the key. |
List<T> | Represents a list of objects that can be accessed by index. Provides methods to search, sort, and modify lists. |
Queue<T> | Represents a first in, first out (FIFO) collection of objects. |
SortedList<TKey,TValue> | Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation. |
Stack<T> | Represents a last in, first out (LIFO) collection of objects. |
For additional information, see Commonly Used Collection Types, Selecting a Collection Class, and System.Collections.Generic.
System.Collections.Concurrent Classes
In the .NET Framework 4 or newer, the collections in the System.Collections.Concurrent namespace provide efficient thread-safe operations for accessing collection items from multiple threads.
The classes in the System.Collections.Concurrent namespace should be used instead of the corresponding types in the System.Collections.Generic and System.Collections namespaces whenever multiple threads are accessing the collection concurrently. For more information, see Thread-Safe Collections and System.Collections.Concurrent.
Some classes included in the System.Collections.Concurrent namespace are BlockingCollection<T>, ConcurrentDictionary<TKey,TValue>, ConcurrentQueue<T>, and ConcurrentStack<T>.
System.Collections Classes
Dot Net Collections
The classes in the System.Collections namespace do not store elements as specifically typed objects, but as objects of type Object
.
Whenever possible, you should use the generic collections in the System.Collections.Generic namespace or the System.Collections.Concurrent namespace instead of the legacy types in the System.Collections
namespace.
The following table lists some of the frequently used classes in the System.Collections
namespace:
Class | Description |
---|---|
ArrayList | Represents an array of objects whose size is dynamically increased as required. |
Hashtable | Represents a collection of key/value pairs that are organized based on the hash code of the key. |
Queue | Represents a first in, first out (FIFO) collection of objects. |
Stack | Represents a last in, first out (LIFO) collection of objects. |
The System.Collections.Specialized namespace provides specialized and strongly typed collection classes, such as string-only collections and linked-list and hybrid dictionaries.
![Net Collections Net Collections](https://i.ytimg.com/vi/e2YvNSSa2Ro/maxresdefault.jpg)
Implementing a Collection of Key/Value Pairs
The Dictionary<TKey,TValue> generic collection enables you to access to elements in a collection by using the key of each element. Each addition to the dictionary consists of a value and its associated key. Retrieving a value by using its key is fast because the Dictionary
class is implemented as a hash table.
The following example creates a Dictionary
collection and iterates through the dictionary by using a foreach
statement.
To instead use a collection initializer to build the Dictionary
collection, you can replace the BuildDictionary
and AddToDictionary
methods with the following method.
The following example uses the ContainsKey method and the Item[TKey] property of Dictionary
to quickly find an item by key. The Item
property enables you to access an item in the elements
collection by using the elements[symbol]
in C#.
The following example instead uses the TryGetValue method quickly find an item by key.
Using LINQ to Access a Collection
LINQ (Language-Integrated Query) can be used to access collections. LINQ queries provide filtering, ordering, and grouping capabilities. For more information, see Getting Started with LINQ in C#.
The following example runs a LINQ query against a generic List
. The LINQ query returns a different collection that contains the results.
Sorting a Collection
The following example illustrates a procedure for sorting a collection. The example sorts instances of the Car
class that are stored in a List<T>. The Car
class implements the IComparable<T> interface, which requires that the CompareTo method be implemented.
Each call to the CompareTo method makes a single comparison that is used for sorting. User-written code in the CompareTo
method returns a value for each comparison of the current object with another object. The value returned is less than zero if the current object is less than the other object, greater than zero if the current object is greater than the other object, and zero if they are equal. This enables you to define in code the criteria for greater than, less than, and equal.
In the ListCars
method, the cars.Sort()
statement sorts the list. This call to the Sort method of the List<T> causes the CompareTo
method to be called automatically for the Car
objects in the List
.
Defining a Custom Collection
You can define a collection by implementing the IEnumerable<T> or IEnumerable interface.
Although you can define a custom collection, it is usually better to instead use the collections that are included in the .NET Framework, which are described in Kinds of Collections earlier in this topic.
The following example defines a custom collection class named AllColors
. This class implements the IEnumerable interface, which requires that the GetEnumerator method be implemented.
The GetEnumerator
method returns an instance of the ColorEnumerator
class. ColorEnumerator
implements the IEnumerator interface, which requires that the Current property, MoveNext method, and Reset method be implemented.
Iterators
An iterator is used to perform a custom iteration over a collection. An iterator can be a method or a get
accessor. An iterator uses a yield return statement to return each element of the collection one at a time.
You call an iterator by using a foreach statement. Each iteration of the foreach
loop calls the iterator. When a yield return
statement is reached in the iterator, an expression is returned, and the current location in code is retained. Execution is restarted from that location the next time that the iterator is called.
Net Collections Definition
For more information, see Iterators (C#).
The following example uses an iterator method. The iterator method has a yield return
statement that is inside a for loop. In the ListEvenNumbers
method, each iteration of the foreach
statement body creates a call to the iterator method, which proceeds to the next yield return
statement.